mrs-toolbox-cli 6.0.2 → 6.0.3

package/npm-cache/_cacache/content-v2/sha512/{13/4a/6e7688b6badc5177a2199a248a43b6139c10d93120d2c2e6a61bed7184527a266ab9f1d49daf44db3dfd3b88950f490346baae64ee251c3fb6ee4350586f → 57/06/e1387a3cc5c6d7bcc3fa4fdbffe684d7b5ec89d6e13280d92c2cc080818292355d972960912a0e5df017ac7cc13eb5acae4337e80d8e1bb7c1b6a472f017}

@@ -57121,7 +57121,7 @@
     "gamma": "1.0.0-gamma.11",
     "rc": "3.5.1-rc.0"
   },
-  "_rev": "97-e508feac73d6dd2d",
+  "_rev": "98-3a0b14f3d888361d",
   "_id": "@aws-sdk/client-sso",
   "readme": "<!-- generated file, do not edit directly -->\n\n# @aws-sdk/client-sso\n\n## Description\n\nAWS SDK for JavaScript SSO Client for Node.js, Browser and React Native.\n\n<p>AWS IAM Identity Center (successor to AWS Single Sign-On) Portal is a web service that makes it easy for you to assign user access to\nIAM Identity Center resources such as the AWS access portal. Users can get AWS account applications and roles\nassigned to them and get federated into the application.</p>\n<note>\n<p>Although AWS Single Sign-On was renamed, the <code>sso</code> and\n<code>identitystore</code> API namespaces will continue to retain their original name for\nbackward compatibility purposes. For more information, see <a href=\"https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html#renamed\">IAM Identity Center rename</a>.</p>\n</note>\n<p>This reference guide describes the IAM Identity Center Portal operations that you can call\nprogramatically and includes detailed information on data types and errors.</p>\n<note>\n<p>AWS provides SDKs that consist of libraries and sample code for various programming\nlanguages and platforms, such as Java, Ruby, .Net, iOS, or Android. The SDKs provide a\nconvenient way to create programmatic access to IAM Identity Center and other AWS services. For more\ninformation about the AWS SDKs, including how to download and install them, see <a href=\"http://aws.amazon.com/tools/\">Tools for Amazon Web Services</a>.</p>\n</note>\n\n## Installing\n\nTo install this package, simply type add or install @aws-sdk/client-sso\nusing your favorite package manager:\n\n- `npm install @aws-sdk/client-sso`\n- `yarn add @aws-sdk/client-sso`\n- `pnpm add @aws-sdk/client-sso`\n\n## Getting Started\n\n### Import\n\nThe AWS SDK is modulized by clients and commands.\nTo send a request, you only need to import the `SSOClient` and\nthe commands you need, for example `ListAccountsCommand`:\n\n```js\n// ES5 example\nconst { SSOClient, ListAccountsCommand } = require(\"@aws-sdk/client-sso\");\n```\n\n```ts\n// ES6+ example\nimport { SSOClient, ListAccountsCommand } from \"@aws-sdk/client-sso\";\n```\n\n### Usage\n\nTo send a request, you:\n\n- Initiate client with configuration (e.g. credentials, region).\n- Initiate command with input parameters.\n- Call `send` operation on client with command object as input.\n- If you are using a custom http handler, you may call `destroy()` to close open connections.\n\n```js\n// a client can be shared by different commands.\nconst client = new SSOClient({ region: \"REGION\" });\n\nconst params = {\n  /** input parameters */\n};\nconst command = new ListAccountsCommand(params);\n```\n\n#### Async/await\n\nWe recommend using [await](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await)\noperator to wait for the promise returned by send operation as follows:\n\n```js\n// async/await.\ntry {\n  const data = await client.send(command);\n  // process data.\n} catch (error) {\n  // error handling.\n} finally {\n  // finally.\n}\n```\n\nAsync-await is clean, concise, intuitive, easy to debug and has better error handling\nas compared to using Promise chains or callbacks.\n\n#### Promises\n\nYou can also use [Promise chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises#chaining)\nto execute send operation.\n\n```js\nclient.send(command).then(\n  (data) => {\n    // process data.\n  },\n  (error) => {\n    // error handling.\n  }\n);\n```\n\nPromises can also be called using `.catch()` and `.finally()` as follows:\n\n```js\nclient\n  .send(command)\n  .then((data) => {\n    // process data.\n  })\n  .catch((error) => {\n    // error handling.\n  })\n  .finally(() => {\n    // finally.\n  });\n```\n\n#### Callbacks\n\nWe do not recommend using callbacks because of [callback hell](http://callbackhell.com/),\nbut they are supported by the send operation.\n\n```js\n// callbacks.\nclient.send(command, (err, data) => {\n  // process err and data.\n});\n```\n\n#### v2 compatible style\n\nThe client can also send requests using v2 compatible style.\nHowever, it results in a bigger bundle size and may be dropped in next major version. More details in the blog post\non [modular packages in AWS SDK for JavaScript](https://aws.amazon.com/blogs/developer/modular-packages-in-aws-sdk-for-javascript/)\n\n```ts\nimport * as AWS from \"@aws-sdk/client-sso\";\nconst client = new AWS.SSO({ region: \"REGION\" });\n\n// async/await.\ntry {\n  const data = await client.listAccounts(params);\n  // process data.\n} catch (error) {\n  // error handling.\n}\n\n// Promises.\nclient\n  .listAccounts(params)\n  .then((data) => {\n    // process data.\n  })\n  .catch((error) => {\n    // error handling.\n  });\n\n// callbacks.\nclient.listAccounts(params, (err, data) => {\n  // process err and data.\n});\n```\n\n### Troubleshooting\n\nWhen the service returns an exception, the error will include the exception information,\nas well as response metadata (e.g. request id).\n\n```js\ntry {\n  const data = await client.send(command);\n  // process data.\n} catch (error) {\n  const { requestId, cfId, extendedRequestId } = error.$metadata;\n  console.log({ requestId, cfId, extendedRequestId });\n  /**\n   * The keys within exceptions are also parsed.\n   * You can access them by specifying exception names:\n   * if (error.name === 'SomeServiceException') {\n   *     const value = error.specialKeyInException;\n   * }\n   */\n}\n```\n\n## Getting Help\n\nPlease use these community resources for getting help.\nWe use the GitHub issues for tracking bugs and feature requests, but have limited bandwidth to address them.\n\n- Visit [Developer Guide](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html)\n  or [API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/index.html).\n- Check out the blog posts tagged with [`aws-sdk-js`](https://aws.amazon.com/blogs/developer/tag/aws-sdk-js/)\n  on AWS Developer Blog.\n- Ask a question on [StackOverflow](https://stackoverflow.com/questions/tagged/aws-sdk-js) and tag it with `aws-sdk-js`.\n- Join the AWS JavaScript community on [gitter](https://gitter.im/aws/aws-sdk-js-v3).\n- If it turns out that you may have found a bug, please [open an issue](https://github.com/aws/aws-sdk-js-v3/issues/new/choose).\n\nTo test your universal JavaScript code in Node.js, browser and react-native environments,\nvisit our [code samples repo](https://github.com/aws-samples/aws-sdk-js-tests).\n\n## Contributing\n\nThis client code is generated automatically. Any modifications will be overwritten the next time the `@aws-sdk/client-sso` package is updated.\nTo contribute to client you can check our [generate clients scripts](https://github.com/aws/aws-sdk-js-v3/tree/main/scripts/generate-clients).\n\n## License\n\nThis SDK is distributed under the\n[Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0),\nsee LICENSE for more information.\n\n## Client Commands (Operations List)\n\n<details>\n<summary>\nGetRoleCredentials\n</summary>\n\n[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sso/command/GetRoleCredentialsCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/GetRoleCredentialsCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/GetRoleCredentialsCommandOutput/)\n\n</details>\n<details>\n<summary>\nListAccountRoles\n</summary>\n\n[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sso/command/ListAccountRolesCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/ListAccountRolesCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/ListAccountRolesCommandOutput/)\n\n</details>\n<details>\n<summary>\nListAccounts\n</summary>\n\n[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sso/command/ListAccountsCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/ListAccountsCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/ListAccountsCommandOutput/)\n\n</details>\n<details>\n<summary>\nLogout\n</summary>\n\n[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sso/command/LogoutCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/LogoutCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso/Interface/LogoutCommandOutput/)\n\n</details>",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{1c/9f/65692367bac4d0801afd0929d368d4ddc15eee7a4c45989a6dbfd6579c19521ba5010a3904d5f74cb3d42dd78e7b11f55b6055823f15694a8db9c3307c6e → 5b/b4/774511ad7d1e13f206a7511826ed9e6b6825bbf57fa5f35a5c1e6b82a704d8ad0d1071e0f0ce37fe2cc079166213c791064356b6f3928a7e1f9bec917710}

@@ -11527,7 +11527,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "90-f1ec65fc48d63021",
+  "_rev": "91-7d20d2bfe379474d",
   "_id": "@aws-sdk/abort-controller",
   "readme": "# @aws-sdk/abort-controller\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/abort-controller/latest.svg)](https://www.npmjs.com/package/@aws-sdk/abort-controller)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/abort-controller.svg)](https://www.npmjs.com/package/@aws-sdk/abort-controller)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{5f/1e/f0818ae6125697a7400a37fbc864ef33b5f446379fa3a2220848fe3df68777c6b9b3e8f5ecdd2d248e6f667bddbf8013c0ed80f0401e1c0b3b3808a4fb58 → 5c/e6/f8fec28adf6c42af6f2aad1cb0774459959c83a503d55b57434e21eb4fe597a49cf46f85c0e76e797c7da4eb4782afe55920d6dcb411ae50a867aa6e04c0}

@@ -9750,7 +9750,7 @@
     "legacy-v4": "4.2.3",
     "legacy-v7": "7.4.6"
   },
-  "_rev": "1920-4510f84e3153ef15",
+  "_rev": "1922-06d5769f8133fdea",
   "_id": "minimatch",
   "readme": "# minimatch\n\nA minimal matching utility.\n\nThis is the matching library used internally by npm.\n\nIt works by converting glob expressions into JavaScript `RegExp`\nobjects.\n\n## Usage\n\n```js\n// hybrid module, load with require() or import\nimport { minimatch } from 'minimatch'\n// or:\nconst { minimatch } = require('minimatch')\n\nminimatch('bar.foo', '*.foo') // true!\nminimatch('bar.foo', '*.bar') // false!\nminimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!\n```\n\n## Features\n\nSupports these glob features:\n\n- Brace Expansion\n- Extended glob matching\n- \"Globstar\" `**` matching\n- [Posix character\n  classes](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html),\n  like `[[:alpha:]]`, supporting the full range of Unicode\n  characters. For example, `[[:alpha:]]` will match against\n  `'é'`, though `[a-zA-Z]` will not. Collating symbol and set\n  matching is not supported, so `[[=e=]]` will _not_ match `'é'`\n  and `[[.ch.]]` will not match `'ch'` in locales where `ch` is\n  considered a single character.\n\nSee:\n\n- `man sh`\n- `man bash` [Pattern\n  Matching](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html)\n- `man 3 fnmatch`\n- `man 5 gitignore`\n\n## Windows\n\n**Please only use forward-slashes in glob expressions.**\n\nThough windows uses either `/` or `\\` as its path separator, only `/`\ncharacters are used by this glob implementation. You must use\nforward-slashes **only** in glob expressions. Back-slashes in patterns\nwill always be interpreted as escape characters, not path separators.\n\nNote that `\\` or `/` _will_ be interpreted as path separators in paths on\nWindows, and will match against `/` in glob expressions.\n\nSo just always use `/` in patterns.\n\n### UNC Paths\n\nOn Windows, UNC paths like `//?/c:/...` or\n`//ComputerName/Share/...` are handled specially.\n\n- Patterns starting with a double-slash followed by some\n  non-slash characters will preserve their double-slash. As a\n  result, a pattern like `//*` will match `//x`, but not `/x`.\n- Patterns staring with `//?/<drive letter>:` will _not_ treat\n  the `?` as a wildcard character. Instead, it will be treated\n  as a normal string.\n- Patterns starting with `//?/<drive letter>:/...` will match\n  file paths starting with `<drive letter>:/...`, and vice versa,\n  as if the `//?/` was not present. This behavior only is\n  present when the drive letters are a case-insensitive match to\n  one another. The remaining portions of the path/pattern are\n  compared case sensitively, unless `nocase:true` is set.\n\nNote that specifying a UNC path using `\\` characters as path\nseparators is always allowed in the file path argument, but only\nallowed in the pattern argument when `windowsPathsNoEscape: true`\nis set in the options.\n\n## Minimatch Class\n\nCreate a minimatch object by instantiating the `minimatch.Minimatch` class.\n\n```javascript\nvar Minimatch = require('minimatch').Minimatch\nvar mm = new Minimatch(pattern, options)\n```\n\n### Properties\n\n- `pattern` The original pattern the minimatch object represents.\n- `options` The options supplied to the constructor.\n- `set` A 2-dimensional array of regexp or string expressions.\n  Each row in the\n  array corresponds to a brace-expanded pattern. Each item in the row\n  corresponds to a single path-part. For example, the pattern\n  `{a,b/c}/d` would expand to a set of patterns like:\n\n        [ [ a, d ]\n        , [ b, c, d ] ]\n\n  If a portion of the pattern doesn't have any \"magic\" in it\n  (that is, it's something like `\"foo\"` rather than `fo*o?`), then it\n  will be left as a string rather than converted to a regular\n  expression.\n\n- `regexp` Created by the `makeRe` method. A single regular expression\n  expressing the entire pattern. This is useful in cases where you wish\n  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.\n- `negate` True if the pattern is negated.\n- `comment` True if the pattern is a comment.\n- `empty` True if the pattern is `\"\"`.\n\n### Methods\n\n- `makeRe()` Generate the `regexp` member if necessary, and return it.\n  Will return `false` if the pattern is invalid.\n- `match(fname)` Return true if the filename matches the pattern, or\n  false otherwise.\n- `matchOne(fileArray, patternArray, partial)` Take a `/`-split\n  filename, and match it against a single row in the `regExpSet`. This\n  method is mainly for internal use, but is exposed so that it can be\n  used by a glob-walker that needs to avoid excessive filesystem calls.\n- `hasMagic()` Returns true if the parsed pattern contains any\n  magic characters. Returns false if all comparator parts are\n  string literals. If the `magicalBraces` option is set on the\n  constructor, then it will consider brace expansions which are\n  not otherwise magical to be magic. If not set, then a pattern\n  like `a{b,c}d` will return `false`, because neither `abd` nor\n  `acd` contain any special glob characters.\n\n  This does **not** mean that the pattern string can be used as a\n  literal filename, as it may contain magic glob characters that\n  are escaped. For example, the pattern `\\\\*` or `[*]` would not\n  be considered to have magic, as the matching portion parses to\n  the literal string `'*'` and would match a path named `'*'`,\n  not `'\\\\*'` or `'[*]'`. The `minimatch.unescape()` method may\n  be used to remove escape characters.\n\nAll other methods are internal, and will be called as necessary.\n\n### minimatch(path, pattern, options)\n\nMain export. Tests a path against the pattern using the options.\n\n```javascript\nvar isJS = minimatch(file, '*.js', { matchBase: true })\n```\n\n### minimatch.filter(pattern, options)\n\nReturns a function that tests its\nsupplied argument, suitable for use with `Array.filter`. Example:\n\n```javascript\nvar javascripts = fileList.filter(minimatch.filter('*.js', { matchBase: true }))\n```\n\n### minimatch.escape(pattern, options = {})\n\nEscape all magic characters in a glob pattern, so that it will\nonly ever match literal strings\n\nIf the `windowsPathsNoEscape` option is used, then characters are\nescaped by wrapping in `[]`, because a magic character wrapped in\na character class can only be satisfied by that exact character.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n### minimatch.unescape(pattern, options = {})\n\nUn-escape a glob string that may contain some escaped characters.\n\nIf the `windowsPathsNoEscape` option is used, then square-brace\nescapes are removed, but not backslash escapes. For example, it\nwill turn the string `'[*]'` into `*`, but it will not turn\n`'\\\\*'` into `'*'`, because `\\` is a path separator in\n`windowsPathsNoEscape` mode.\n\nWhen `windowsPathsNoEscape` is not set, then both brace escapes\nand backslash escapes are removed.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n### minimatch.match(list, pattern, options)\n\nMatch against the list of\nfiles, in the style of fnmatch or glob. If nothing is matched, and\noptions.nonull is set, then return a list containing the pattern itself.\n\n```javascript\nvar javascripts = minimatch.match(fileList, '*.js', { matchBase: true })\n```\n\n### minimatch.makeRe(pattern, options)\n\nMake a regular expression object from the pattern.\n\n## Options\n\nAll options are `false` by default.\n\n### debug\n\nDump a ton of stuff to stderr.\n\n### nobrace\n\nDo not expand `{a,b}` and `{1..3}` brace sets.\n\n### noglobstar\n\nDisable `**` matching against multiple folder names.\n\n### dot\n\nAllow patterns to match filenames starting with a period, even if\nthe pattern does not explicitly have a period in that spot.\n\nNote that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`\nis set.\n\n### noext\n\nDisable \"extglob\" style patterns like `+(a|b)`.\n\n### nocase\n\nPerform a case-insensitive match.\n\n### nocaseMagicOnly\n\nWhen used with `{nocase: true}`, create regular expressions that\nare case-insensitive, but leave string match portions untouched.\nHas no effect when used without `{nocase: true}`\n\nUseful when some other form of case-insensitive matching is used,\nor if the original string representation is useful in some other\nway.\n\n### nonull\n\nWhen a match is not found by `minimatch.match`, return a list containing\nthe pattern itself if this option is set. When not set, an empty list\nis returned if there are no matches.\n\n### magicalBraces\n\nThis only affects the results of the `Minimatch.hasMagic` method.\n\nIf the pattern contains brace expansions, such as `a{b,c}d`, but\nno other magic characters, then the `Minimatch.hasMagic()` method\nwill return `false` by default. When this option set, it will\nreturn `true` for brace expansion as well as other magic glob\ncharacters.\n\n### matchBase\n\nIf set, then patterns without slashes will be matched\nagainst the basename of the path if it contains slashes. For example,\n`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.\n\n### nocomment\n\nSuppress the behavior of treating `#` at the start of a pattern as a\ncomment.\n\n### nonegate\n\nSuppress the behavior of treating a leading `!` character as negation.\n\n### flipNegate\n\nReturns from negate expressions the same as if they were not negated.\n(Ie, true on a hit, false on a miss.)\n\n### partial\n\nCompare a partial path to a pattern. As long as the parts of the path that\nare present are not contradicted by the pattern, it will be treated as a\nmatch. This is useful in applications where you're walking through a\nfolder structure, and don't yet have the full path, but want to ensure that\nyou do not walk down paths that can never be a match.\n\nFor example,\n\n```js\nminimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d\nminimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d\nminimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a\n```\n\n### windowsPathsNoEscape\n\nUse `\\\\` as a path separator _only_, and _never_ as an escape\ncharacter. If set, all `\\\\` characters are replaced with `/` in\nthe pattern. Note that this makes it **impossible** to match\nagainst paths containing literal glob pattern characters, but\nallows matching with patterns constructed using `path.join()` and\n`path.resolve()` on Windows platforms, mimicking the (buggy!)\nbehavior of earlier versions on Windows. Please use with\ncaution, and be mindful of [the caveat about Windows\npaths](#windows).\n\nFor legacy reasons, this is also set if\n`options.allowWindowsEscape` is set to the exact value `false`.\n\n### windowsNoMagicRoot\n\nWhen a pattern starts with a UNC path or drive letter, and in\n`nocase:true` mode, do not convert the root portions of the\npattern into a case-insensitive regular expression, and instead\nleave them as strings.\n\nThis is the default when the platform is `win32` and\n`nocase:true` is set.\n\n### preserveMultipleSlashes\n\nBy default, multiple `/` characters (other than the leading `//`\nin a UNC path, see \"UNC Paths\" above) are treated as a single\n`/`.\n\nThat is, a pattern like `a///b` will match the file path `a/b`.\n\nSet `preserveMultipleSlashes: true` to suppress this behavior.\n\n### optimizationLevel\n\nA number indicating the level of optimization that should be done\nto the pattern prior to parsing and using it for matches.\n\nGlobstar parts `**` are always converted to `*` when `noglobstar`\nis set, and multiple adjacent `**` parts are converted into a\nsingle `**` (ie, `a/**/**/b` will be treated as `a/**/b`, as this\nis equivalent in all cases).\n\n- `0` - Make no further changes. In this mode, `.` and `..` are\n  maintained in the pattern, meaning that they must also appear\n  in the same position in the test path string. Eg, a pattern\n  like `a/*/../c` will match the string `a/b/../c` but not the\n  string `a/c`.\n- `1` - (default) Remove cases where a double-dot `..` follows a\n  pattern portion that is not `**`, `.`, `..`, or empty `''`. For\n  example, the pattern `./a/b/../*` is converted to `./a/*`, and\n  so it will match the path string `./a/c`, but not the path\n  string `./a/b/../c`. Dots and empty path portions in the\n  pattern are preserved.\n- `2` (or higher) - Much more aggressive optimizations, suitable\n  for use with file-walking cases:\n\n  - Remove cases where a double-dot `..` follows a pattern\n    portion that is not `**`, `.`, or empty `''`. Remove empty\n    and `.` portions of the pattern, where safe to do so (ie,\n    anywhere other than the last position, the first position, or\n    the second position in a pattern starting with `/`, as this\n    may indicate a UNC path on Windows).\n  - Convert patterns containing `<pre>/**/../<p>/<rest>` into the\n    equivalent `<pre>/{..,**}/<p>/<rest>`, where `<p>` is a\n    a pattern portion other than `.`, `..`, `**`, or empty\n    `''`.\n  - Dedupe patterns where a `**` portion is present in one and\n    omitted in another, and it is not the final path portion, and\n    they are otherwise equivalent. So `{a/**/b,a/b}` becomes\n    `a/**/b`, because `**` matches against an empty path portion.\n  - Dedupe patterns where a `*` portion is present in one, and a\n    non-dot pattern other than `**`, `.`, `..`, or `''` is in the\n    same position in the other. So `a/{*,x}/b` becomes `a/*/b`,\n    because `*` can match against `x`.\n\n  While these optimizations improve the performance of\n  file-walking use cases such as [glob](http://npm.im/glob) (ie,\n  the reason this module exists), there are cases where it will\n  fail to match a literal string that would have been matched in\n  optimization level 1 or 0.\n\n  Specifically, while the `Minimatch.match()` method will\n  optimize the file path string in the same ways, resulting in\n  the same matches, it will fail when tested with the regular\n  expression provided by `Minimatch.makeRe()`, unless the path\n  string is first processed with\n  `minimatch.levelTwoFileOptimize()` or similar.\n\n### platform\n\nWhen set to `win32`, this will trigger all windows-specific\nbehaviors (special handling for UNC paths, and treating `\\` as\nseparators in file paths for comparison.)\n\nDefaults to the value of `process.platform`.\n\n## Comparisons to other fnmatch/glob implementations\n\nWhile strict compliance with the existing standards is a\nworthwhile goal, some discrepancies exist between minimatch and\nother implementations. Some are intentional, and some are\nunavoidable.\n\nIf the pattern starts with a `!` character, then it is negated. Set the\n`nonegate` flag to suppress this behavior, and treat leading `!`\ncharacters normally. This is perhaps relevant if you wish to start the\npattern with a negative extglob pattern like `!(a|B)`. Multiple `!`\ncharacters at the start of a pattern will negate the pattern multiple\ntimes.\n\nIf a pattern starts with `#`, then it is treated as a comment, and\nwill not match anything. Use `\\#` to match a literal `#` at the\nstart of a line, or set the `nocomment` flag to suppress this behavior.\n\nThe double-star character `**` is supported by default, unless the\n`noglobstar` flag is set. This is supported in the manner of bsdglob\nand bash 4.1, where `**` only has special significance if it is the only\nthing in a path part. That is, `a/**/b` will match `a/x/y/b`, but\n`a/**b` will not.\n\nIf an escaped pattern has no matches, and the `nonull` flag is set,\nthen minimatch.match returns the pattern as-provided, rather than\ninterpreting the character escapes. For example,\n`minimatch.match([], \"\\\\*a\\\\?\")` will return `\"\\\\*a\\\\?\"` rather than\n`\"*a?\"`. This is akin to setting the `nullglob` option in bash, except\nthat it does not resolve escaped pattern characters.\n\nIf brace expansion is not disabled, then it is performed before any\nother interpretation of the glob pattern. Thus, a pattern like\n`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded\n**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are\nchecked for validity. Since those two are valid, matching proceeds.\n\nNegated extglob patterns are handled as closely as possible to\nBash semantics, but there are some cases with negative extglobs\nwhich are exceedingly difficult to express in a JavaScript\nregular expression. In particular the negated pattern\n`<start>!(<pattern>*|)*` will in bash match anything that does\nnot start with `<start><pattern>`. However,\n`<start>!(<pattern>*)*` _will_ match paths starting with\n`<start><pattern>`, because the empty string can match against\nthe negated portion. In this library, `<start>!(<pattern>*|)*`\nwill _not_ match any pattern starting with `<start>`, due to a\ndifference in precisely which patterns are considered \"greedy\" in\nRegular Expressions vs bash path expansion. This may be fixable,\nbut not without incurring some complexity and performance costs,\nand the trade-off seems to not be worth pursuing.\n\nNote that `fnmatch(3)` in libc is an extremely naive string comparison\nmatcher, which does not do anything special for slashes. This library is\ndesigned to be used in glob searching and file walkers, and so it does do\nspecial things with `/`. Thus, `foo*` will not match `foo/bar` in this\nlibrary, even though it would in `fnmatch(3)`.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{31/99/3a63521eec320a4ff29f81ee8928eff93b1a55f59c6db289e79f5a51454795fb451e260b31ad686f22287676dbaff0954c25ae7dddcb494632eba742de6b → 5e/f0/bcdb17ce20170307a81d3846697cb25cfd4cdb0516fadcb2770a24ff32fa99d1d920bff800133c666c1876a4e7c0b0110117c114096476384aa6bc69d97a}

@@ -2018,7 +2018,7 @@
   "dist-tags": {
     "latest": "4.5.0"
   },
-  "_rev": "67-63c3a4135c05189b",
+  "_rev": "68-edb8b738b7b8e59d",
   "_id": "lodash.difference",
   "readme": "# lodash.difference v4.5.0\n\nThe [lodash](https://lodash.com/) method `_.difference` exported as a [Node.js](https://nodejs.org/) module.\n\n## Installation\n\nUsing npm:\n```bash\n$ {sudo -H} npm i -g npm\n$ npm i --save lodash.difference\n```\n\nIn Node.js:\n```js\nvar difference = require('lodash.difference');\n```\n\nSee the [documentation](https://lodash.com/docs#difference) or [package source](https://github.com/lodash/lodash/blob/4.5.0-npm-packages/lodash.difference) for more details.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{19/95/2e39aa1d813ece934bb98e0c28eeee01e5e2abd894fc5b9ae669ecf222d9be51ea1682e52a80920954e5cf1f3b7bea01f4e39fc3a8e5ac4560a32f538c4c → 60/3d/900c991f60e6390be011cb93ef62ba1a69da44e04564a126facc5d56a0cb2df300aa85013ebb2d4a379ac6efc035f093a1f932f2b72acb934009cc45e390}

@@ -758,7 +758,7 @@
   "dist-tags": {
     "latest": "5.2.1"
   },
-  "_rev": "1716-6a3e8afb1fbf2244",
+  "_rev": "1718-33e99b811a4afcd7",
   "_id": "safe-buffer",
   "readme": "# safe-buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]\n\n[travis-image]: https://img.shields.io/travis/feross/safe-buffer/master.svg\n[travis-url]: https://travis-ci.org/feross/safe-buffer\n[npm-image]: https://img.shields.io/npm/v/safe-buffer.svg\n[npm-url]: https://npmjs.org/package/safe-buffer\n[downloads-image]: https://img.shields.io/npm/dm/safe-buffer.svg\n[downloads-url]: https://npmjs.org/package/safe-buffer\n[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg\n[standard-url]: https://standardjs.com\n\n#### Safer Node.js Buffer API\n\n**Use the new Node.js Buffer APIs (`Buffer.from`, `Buffer.alloc`,\n`Buffer.allocUnsafe`, `Buffer.allocUnsafeSlow`) in all versions of Node.js.**\n\n**Uses the built-in implementation when available.**\n\n## install\n\n```\nnpm install safe-buffer\n```\n\n## usage\n\nThe goal of this package is to provide a safe replacement for the node.js `Buffer`.\n\nIt's a drop-in replacement for `Buffer`. You can use it by adding one `require` line to\nthe top of your node.js modules:\n\n```js\nvar Buffer = require('safe-buffer').Buffer\n\n// Existing buffer code will continue to work without issues:\n\nnew Buffer('hey', 'utf8')\nnew Buffer([1, 2, 3], 'utf8')\nnew Buffer(obj)\nnew Buffer(16) // create an uninitialized buffer (potentially unsafe)\n\n// But you can use these new explicit APIs to make clear what you want:\n\nBuffer.from('hey', 'utf8') // convert from many types to a Buffer\nBuffer.alloc(16) // create a zero-filled buffer (safe)\nBuffer.allocUnsafe(16) // create an uninitialized buffer (potentially unsafe)\n```\n\n## api\n\n### Class Method: Buffer.from(array)\n<!-- YAML\nadded: v3.0.0\n-->\n\n* `array` {Array}\n\nAllocates a new `Buffer` using an `array` of octets.\n\n```js\nconst buf = Buffer.from([0x62,0x75,0x66,0x66,0x65,0x72]);\n  // creates a new Buffer containing ASCII bytes\n  // ['b','u','f','f','e','r']\n```\n\nA `TypeError` will be thrown if `array` is not an `Array`.\n\n### Class Method: Buffer.from(arrayBuffer[, byteOffset[, length]])\n<!-- YAML\nadded: v5.10.0\n-->\n\n* `arrayBuffer` {ArrayBuffer} The `.buffer` property of a `TypedArray` or\n  a `new ArrayBuffer()`\n* `byteOffset` {Number} Default: `0`\n* `length` {Number} Default: `arrayBuffer.length - byteOffset`\n\nWhen passed a reference to the `.buffer` property of a `TypedArray` instance,\nthe newly created `Buffer` will share the same allocated memory as the\nTypedArray.\n\n```js\nconst arr = new Uint16Array(2);\narr[0] = 5000;\narr[1] = 4000;\n\nconst buf = Buffer.from(arr.buffer); // shares the memory with arr;\n\nconsole.log(buf);\n  // Prints: <Buffer 88 13 a0 0f>\n\n// changing the TypedArray changes the Buffer also\narr[1] = 6000;\n\nconsole.log(buf);\n  // Prints: <Buffer 88 13 70 17>\n```\n\nThe optional `byteOffset` and `length` arguments specify a memory range within\nthe `arrayBuffer` that will be shared by the `Buffer`.\n\n```js\nconst ab = new ArrayBuffer(10);\nconst buf = Buffer.from(ab, 0, 2);\nconsole.log(buf.length);\n  // Prints: 2\n```\n\nA `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer`.\n\n### Class Method: Buffer.from(buffer)\n<!-- YAML\nadded: v3.0.0\n-->\n\n* `buffer` {Buffer}\n\nCopies the passed `buffer` data onto a new `Buffer` instance.\n\n```js\nconst buf1 = Buffer.from('buffer');\nconst buf2 = Buffer.from(buf1);\n\nbuf1[0] = 0x61;\nconsole.log(buf1.toString());\n  // 'auffer'\nconsole.log(buf2.toString());\n  // 'buffer' (copy is not changed)\n```\n\nA `TypeError` will be thrown if `buffer` is not a `Buffer`.\n\n### Class Method: Buffer.from(str[, encoding])\n<!-- YAML\nadded: v5.10.0\n-->\n\n* `str` {String} String to encode.\n* `encoding` {String} Encoding to use, Default: `'utf8'`\n\nCreates a new `Buffer` containing the given JavaScript string `str`. If\nprovided, the `encoding` parameter identifies the character encoding.\nIf not provided, `encoding` defaults to `'utf8'`.\n\n```js\nconst buf1 = Buffer.from('this is a tést');\nconsole.log(buf1.toString());\n  // prints: this is a tést\nconsole.log(buf1.toString('ascii'));\n  // prints: this is a tC)st\n\nconst buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');\nconsole.log(buf2.toString());\n  // prints: this is a tést\n```\n\nA `TypeError` will be thrown if `str` is not a string.\n\n### Class Method: Buffer.alloc(size[, fill[, encoding]])\n<!-- YAML\nadded: v5.10.0\n-->\n\n* `size` {Number}\n* `fill` {Value} Default: `undefined`\n* `encoding` {String} Default: `utf8`\n\nAllocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the\n`Buffer` will be *zero-filled*.\n\n```js\nconst buf = Buffer.alloc(5);\nconsole.log(buf);\n  // <Buffer 00 00 00 00 00>\n```\n\nThe `size` must be less than or equal to the value of\n`require('buffer').kMaxLength` (on 64-bit architectures, `kMaxLength` is\n`(2^31)-1`). Otherwise, a [`RangeError`][] is thrown. A zero-length Buffer will\nbe created if a `size` less than or equal to 0 is specified.\n\nIf `fill` is specified, the allocated `Buffer` will be initialized by calling\n`buf.fill(fill)`. See [`buf.fill()`][] for more information.\n\n```js\nconst buf = Buffer.alloc(5, 'a');\nconsole.log(buf);\n  // <Buffer 61 61 61 61 61>\n```\n\nIf both `fill` and `encoding` are specified, the allocated `Buffer` will be\ninitialized by calling `buf.fill(fill, encoding)`. For example:\n\n```js\nconst buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');\nconsole.log(buf);\n  // <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>\n```\n\nCalling `Buffer.alloc(size)` can be significantly slower than the alternative\n`Buffer.allocUnsafe(size)` but ensures that the newly created `Buffer` instance\ncontents will *never contain sensitive data*.\n\nA `TypeError` will be thrown if `size` is not a number.\n\n### Class Method: Buffer.allocUnsafe(size)\n<!-- YAML\nadded: v5.10.0\n-->\n\n* `size` {Number}\n\nAllocates a new *non-zero-filled* `Buffer` of `size` bytes.  The `size` must\nbe less than or equal to the value of `require('buffer').kMaxLength` (on 64-bit\narchitectures, `kMaxLength` is `(2^31)-1`). Otherwise, a [`RangeError`][] is\nthrown. A zero-length Buffer will be created if a `size` less than or equal to\n0 is specified.\n\nThe underlying memory for `Buffer` instances created in this way is *not\ninitialized*. The contents of the newly created `Buffer` are unknown and\n*may contain sensitive data*. Use [`buf.fill(0)`][] to initialize such\n`Buffer` instances to zeroes.\n\n```js\nconst buf = Buffer.allocUnsafe(5);\nconsole.log(buf);\n  // <Buffer 78 e0 82 02 01>\n  // (octets will be different, every time)\nbuf.fill(0);\nconsole.log(buf);\n  // <Buffer 00 00 00 00 00>\n```\n\nA `TypeError` will be thrown if `size` is not a number.\n\nNote that the `Buffer` module pre-allocates an internal `Buffer` instance of\nsize `Buffer.poolSize` that is used as a pool for the fast allocation of new\n`Buffer` instances created using `Buffer.allocUnsafe(size)` (and the deprecated\n`new Buffer(size)` constructor) only when `size` is less than or equal to\n`Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two). The default\nvalue of `Buffer.poolSize` is `8192` but can be modified.\n\nUse of this pre-allocated internal memory pool is a key difference between\ncalling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.\nSpecifically, `Buffer.alloc(size, fill)` will *never* use the internal Buffer\npool, while `Buffer.allocUnsafe(size).fill(fill)` *will* use the internal\nBuffer pool if `size` is less than or equal to half `Buffer.poolSize`. The\ndifference is subtle but can be important when an application requires the\nadditional performance that `Buffer.allocUnsafe(size)` provides.\n\n### Class Method: Buffer.allocUnsafeSlow(size)\n<!-- YAML\nadded: v5.10.0\n-->\n\n* `size` {Number}\n\nAllocates a new *non-zero-filled* and non-pooled `Buffer` of `size` bytes.  The\n`size` must be less than or equal to the value of\n`require('buffer').kMaxLength` (on 64-bit architectures, `kMaxLength` is\n`(2^31)-1`). Otherwise, a [`RangeError`][] is thrown. A zero-length Buffer will\nbe created if a `size` less than or equal to 0 is specified.\n\nThe underlying memory for `Buffer` instances created in this way is *not\ninitialized*. The contents of the newly created `Buffer` are unknown and\n*may contain sensitive data*. Use [`buf.fill(0)`][] to initialize such\n`Buffer` instances to zeroes.\n\nWhen using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,\nallocations under 4KB are, by default, sliced from a single pre-allocated\n`Buffer`. This allows applications to avoid the garbage collection overhead of\ncreating many individually allocated Buffers. This approach improves both\nperformance and memory usage by eliminating the need to track and cleanup as\nmany `Persistent` objects.\n\nHowever, in the case where a developer may need to retain a small chunk of\nmemory from a pool for an indeterminate amount of time, it may be appropriate\nto create an un-pooled Buffer instance using `Buffer.allocUnsafeSlow()` then\ncopy out the relevant bits.\n\n```js\n// need to keep around a few small chunks of memory\nconst store = [];\n\nsocket.on('readable', () => {\n  const data = socket.read();\n  // allocate for retained data\n  const sb = Buffer.allocUnsafeSlow(10);\n  // copy the data into the new allocation\n  data.copy(sb, 0, 0, 10);\n  store.push(sb);\n});\n```\n\nUse of `Buffer.allocUnsafeSlow()` should be used only as a last resort *after*\na developer has observed undue memory retention in their applications.\n\nA `TypeError` will be thrown if `size` is not a number.\n\n### All the Rest\n\nThe rest of the `Buffer` API is exactly the same as in node.js.\n[See the docs](https://nodejs.org/api/buffer.html).\n\n\n## Related links\n\n- [Node.js issue: Buffer(number) is unsafe](https://github.com/nodejs/node/issues/4660)\n- [Node.js Enhancement Proposal: Buffer.from/Buffer.alloc/Buffer.zalloc/Buffer() soft-deprecate](https://github.com/nodejs/node-eps/pull/4)\n\n## Why is `Buffer` unsafe?\n\nToday, the node.js `Buffer` constructor is overloaded to handle many different argument\ntypes like `String`, `Array`, `Object`, `TypedArrayView` (`Uint8Array`, etc.),\n`ArrayBuffer`, and also `Number`.\n\nThe API is optimized for convenience: you can throw any type at it, and it will try to do\nwhat you want.\n\nBecause the Buffer constructor is so powerful, you often see code like this:\n\n```js\n// Convert UTF-8 strings to hex\nfunction toHex (str) {\n  return new Buffer(str).toString('hex')\n}\n```\n\n***But what happens if `toHex` is called with a `Number` argument?***\n\n### Remote Memory Disclosure\n\nIf an attacker can make your program call the `Buffer` constructor with a `Number`\nargument, then they can make it allocate uninitialized memory from the node.js process.\nThis could potentially disclose TLS private keys, user data, or database passwords.\n\nWhen the `Buffer` constructor is passed a `Number` argument, it returns an\n**UNINITIALIZED** block of memory of the specified `size`. When you create a `Buffer` like\nthis, you **MUST** overwrite the contents before returning it to the user.\n\nFrom the [node.js docs](https://nodejs.org/api/buffer.html#buffer_new_buffer_size):\n\n> `new Buffer(size)`\n>\n> - `size` Number\n>\n> The underlying memory for `Buffer` instances created in this way is not initialized.\n> **The contents of a newly created `Buffer` are unknown and could contain sensitive\n> data.** Use `buf.fill(0)` to initialize a Buffer to zeroes.\n\n(Emphasis our own.)\n\nWhenever the programmer intended to create an uninitialized `Buffer` you often see code\nlike this:\n\n```js\nvar buf = new Buffer(16)\n\n// Immediately overwrite the uninitialized buffer with data from another buffer\nfor (var i = 0; i < buf.length; i++) {\n  buf[i] = otherBuf[i]\n}\n```\n\n\n### Would this ever be a problem in real code?\n\nYes. It's surprisingly common to forget to check the type of your variables in a\ndynamically-typed language like JavaScript.\n\nUsually the consequences of assuming the wrong type is that your program crashes with an\nuncaught exception. But the failure mode for forgetting to check the type of arguments to\nthe `Buffer` constructor is more catastrophic.\n\nHere's an example of a vulnerable service that takes a JSON payload and converts it to\nhex:\n\n```js\n// Take a JSON payload {str: \"some string\"} and convert it to hex\nvar server = http.createServer(function (req, res) {\n  var data = ''\n  req.setEncoding('utf8')\n  req.on('data', function (chunk) {\n    data += chunk\n  })\n  req.on('end', function () {\n    var body = JSON.parse(data)\n    res.end(new Buffer(body.str).toString('hex'))\n  })\n})\n\nserver.listen(8080)\n```\n\nIn this example, an http client just has to send:\n\n```json\n{\n  \"str\": 1000\n}\n```\n\nand it will get back 1,000 bytes of uninitialized memory from the server.\n\nThis is a very serious bug. It's similar in severity to the\n[the Heartbleed bug](http://heartbleed.com/) that allowed disclosure of OpenSSL process\nmemory by remote attackers.\n\n\n### Which real-world packages were vulnerable?\n\n#### [`bittorrent-dht`](https://www.npmjs.com/package/bittorrent-dht)\n\n[Mathias Buus](https://github.com/mafintosh) and I\n([Feross Aboukhadijeh](http://feross.org/)) found this issue in one of our own packages,\n[`bittorrent-dht`](https://www.npmjs.com/package/bittorrent-dht). The bug would allow\nanyone on the internet to send a series of messages to a user of `bittorrent-dht` and get\nthem to reveal 20 bytes at a time of uninitialized memory from the node.js process.\n\nHere's\n[the commit](https://github.com/feross/bittorrent-dht/commit/6c7da04025d5633699800a99ec3fbadf70ad35b8)\nthat fixed it. We released a new fixed version, created a\n[Node Security Project disclosure](https://nodesecurity.io/advisories/68), and deprecated all\nvulnerable versions on npm so users will get a warning to upgrade to a newer version.\n\n#### [`ws`](https://www.npmjs.com/package/ws)\n\nThat got us wondering if there were other vulnerable packages. Sure enough, within a short\nperiod of time, we found the same issue in [`ws`](https://www.npmjs.com/package/ws), the\nmost popular WebSocket implementation in node.js.\n\nIf certain APIs were called with `Number` parameters instead of `String` or `Buffer` as\nexpected, then uninitialized server memory would be disclosed to the remote peer.\n\nThese were the vulnerable methods:\n\n```js\nsocket.send(number)\nsocket.ping(number)\nsocket.pong(number)\n```\n\nHere's a vulnerable socket server with some echo functionality:\n\n```js\nserver.on('connection', function (socket) {\n  socket.on('message', function (message) {\n    message = JSON.parse(message)\n    if (message.type === 'echo') {\n      socket.send(message.data) // send back the user's message\n    }\n  })\n})\n```\n\n`socket.send(number)` called on the server, will disclose server memory.\n\nHere's [the release](https://github.com/websockets/ws/releases/tag/1.0.1) where the issue\nwas fixed, with a more detailed explanation. Props to\n[Arnout Kazemier](https://github.com/3rd-Eden) for the quick fix. Here's the\n[Node Security Project disclosure](https://nodesecurity.io/advisories/67).\n\n\n### What's the solution?\n\nIt's important that node.js offers a fast way to get memory otherwise performance-critical\napplications would needlessly get a lot slower.\n\nBut we need a better way to *signal our intent* as programmers. **When we want\nuninitialized memory, we should request it explicitly.**\n\nSensitive functionality should not be packed into a developer-friendly API that loosely\naccepts many different types. This type of API encourages the lazy practice of passing\nvariables in without checking the type very carefully.\n\n#### A new API: `Buffer.allocUnsafe(number)`\n\nThe functionality of creating buffers with uninitialized memory should be part of another\nAPI. We propose `Buffer.allocUnsafe(number)`. This way, it's not part of an API that\nfrequently gets user input of all sorts of different types passed into it.\n\n```js\nvar buf = Buffer.allocUnsafe(16) // careful, uninitialized memory!\n\n// Immediately overwrite the uninitialized buffer with data from another buffer\nfor (var i = 0; i < buf.length; i++) {\n  buf[i] = otherBuf[i]\n}\n```\n\n\n### How do we fix node.js core?\n\nWe sent [a PR to node.js core](https://github.com/nodejs/node/pull/4514) (merged as\n`semver-major`) which defends against one case:\n\n```js\nvar str = 16\nnew Buffer(str, 'utf8')\n```\n\nIn this situation, it's implied that the programmer intended the first argument to be a\nstring, since they passed an encoding as a second argument. Today, node.js will allocate\nuninitialized memory in the case of `new Buffer(number, encoding)`, which is probably not\nwhat the programmer intended.\n\nBut this is only a partial solution, since if the programmer does `new Buffer(variable)`\n(without an `encoding` parameter) there's no way to know what they intended. If `variable`\nis sometimes a number, then uninitialized memory will sometimes be returned.\n\n### What's the real long-term fix?\n\nWe could deprecate and remove `new Buffer(number)` and use `Buffer.allocUnsafe(number)` when\nwe need uninitialized memory. But that would break 1000s of packages.\n\n~~We believe the best solution is to:~~\n\n~~1. Change `new Buffer(number)` to return safe, zeroed-out memory~~\n\n~~2. Create a new API for creating uninitialized Buffers. We propose: `Buffer.allocUnsafe(number)`~~\n\n#### Update\n\nWe now support adding three new APIs:\n\n- `Buffer.from(value)` - convert from any type to a buffer\n- `Buffer.alloc(size)` - create a zero-filled buffer\n- `Buffer.allocUnsafe(size)` - create an uninitialized buffer with given size\n\nThis solves the core problem that affected `ws` and `bittorrent-dht` which is\n`Buffer(variable)` getting tricked into taking a number argument.\n\nThis way, existing code continues working and the impact on the npm ecosystem will be\nminimal. Over time, npm maintainers can migrate performance-critical code to use\n`Buffer.allocUnsafe(number)` instead of `new Buffer(number)`.\n\n\n### Conclusion\n\nWe think there's a serious design issue with the `Buffer` API as it exists today. It\npromotes insecure software by putting high-risk functionality into a convenient API\nwith friendly \"developer ergonomics\".\n\nThis wasn't merely a theoretical exercise because we found the issue in some of the\nmost popular npm packages.\n\nFortunately, there's an easy fix that can be applied today. Use `safe-buffer` in place of\n`buffer`.\n\n```js\nvar Buffer = require('safe-buffer').Buffer\n```\n\nEventually, we hope that node.js core can switch to this new, safer behavior. We believe\nthe impact on the ecosystem would be minimal since it's not a breaking change.\nWell-maintained, popular packages would be updated to use `Buffer.alloc` quickly, while\nolder, insecure packages would magically become safe from this attack vector.\n\n\n## links\n\n- [Node.js PR: buffer: throw if both length and enc are passed](https://github.com/nodejs/node/pull/4514)\n- [Node Security Project disclosure for `ws`](https://nodesecurity.io/advisories/67)\n- [Node Security Project disclosure for`bittorrent-dht`](https://nodesecurity.io/advisories/68)\n\n\n## credit\n\nThe original issues in `bittorrent-dht`\n([disclosure](https://nodesecurity.io/advisories/68)) and\n`ws` ([disclosure](https://nodesecurity.io/advisories/67)) were discovered by\n[Mathias Buus](https://github.com/mafintosh) and\n[Feross Aboukhadijeh](http://feross.org/).\n\nThanks to [Adam Baldwin](https://github.com/evilpacket) for helping disclose these issues\nand for his work running the [Node Security Project](https://nodesecurity.io/).\n\nThanks to [John Hiesey](https://github.com/jhiesey) for proofreading this README and\nauditing the code.\n\n\n## license\n\nMIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{a2/51/de33b350f52e062a24178086e11523ca9ff4f6b006dc9d4136ae91bb75508feddaf6839328a79218a1d5e99943a085c920f99e283a6bd6d20e336c88a73a → 60/e4/a83b17932923ad987bcd869179497aa5cccb0caa40f1347fe0d932de963a467d64aad25eb6db159ae7ae510d0c8f561279086907cba896fa33633b7d279c}

@@ -411,7 +411,7 @@
   "dist-tags": {
     "latest": "1.4.0"
   },
-  "_rev": "1716-0adcf32f4e844b21",
+  "_rev": "1717-c8389cf2ed7c670a",
   "_id": "once",
   "readme": "# once\n\nOnly call a function once.\n\n## usage\n\n```javascript\nvar once = require('once')\n\nfunction load (file, cb) {\n  cb = once(cb)\n  loader.load('file')\n  loader.once('load', cb)\n  loader.once('error', cb)\n}\n```\n\nOr add to the Function.prototype in a responsible way:\n\n```javascript\n// only has to be done once\nrequire('once').proto()\n\nfunction load (file, cb) {\n  cb = cb.once()\n  loader.load('file')\n  loader.once('load', cb)\n  loader.once('error', cb)\n}\n```\n\nIronically, the prototype feature makes this module twice as\ncomplicated as necessary.\n\nTo check whether you function has been called, use `fn.called`. Once the\nfunction is called for the first time the return value of the original\nfunction is saved in `fn.value` and subsequent calls will continue to\nreturn this value.\n\n```javascript\nvar once = require('once')\n\nfunction load (cb) {\n  cb = once(cb)\n  var stream = createStream()\n  stream.once('data', cb)\n  stream.once('end', function () {\n    if (!cb.called) cb(new Error('not found'))\n  })\n}\n```\n\n## `once.strict(func)`\n\nThrow an error if the function is called twice.\n\nSome functions are expected to be called only once. Using `once` for them would\npotentially hide logical errors.\n\nIn the example below, the `greet` function has to call the callback only once:\n\n```javascript\nfunction greet (name, cb) {\n  // return is missing from the if statement\n  // when no name is passed, the callback is called twice\n  if (!name) cb('Hello anonymous')\n  cb('Hello ' + name)\n}\n\nfunction log (msg) {\n  console.log(msg)\n}\n\n// this will print 'Hello anonymous' but the logical error will be missed\ngreet(null, once(msg))\n\n// once.strict will print 'Hello anonymous' and throw an error when the callback will be called the second time\ngreet(null, once.strict(msg))\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{11/eb/d446db5dbfb3710ab74832e315423b4862e23561d1e4177db734eeaac9071f0a9ffade89db5cd81e625ed82928c785b21ae4ea157c776c0b9efdd06111d1 → 61/9e/58bd1cac1f44779fad68af3be77e3a211407a27f8c46ee53ff155e63ad6d3bbf28e5f41972a9f659a43a1afd96ead84469898facf66a17cf197185de4b1b}

@@ -25517,7 +25517,7 @@
   "dist-tags": {
     "latest": "3.777.0"
   },
-  "_rev": "98-6f2a7c4de40478e7",
+  "_rev": "99-1fa62789651156d2",
   "_id": "@aws-sdk/token-providers",
   "readme": "# @aws-sdk/token-providers\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/token-providers/latest.svg)](https://www.npmjs.com/package/@aws-sdk/token-providers)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/token-providers.svg)](https://www.npmjs.com/package/@aws-sdk/token-providers)\n\nA collection of all token providers. The token providers should be used when the authorization\ntype is going to be token based. For example, the `bearer` authorization type set using\n[httpBearerAuth trait][http-bearer-auth-trait] in Smithy.\n\n## Static Token Provider\n\n```ts\nimport { fromStatic } from \"@aws-sdk/token-providers\";\n\nconst token = { token: \"TOKEN\" };\nconst staticTokenProvider = fromStatic(token);\n\nconst staticToken = await staticTokenProvider(); // returns { token: \"TOKEN\" }\n```\n\n## SSO Token Provider\n\n```ts\nimport { fromSso } from \"@aws-sdk/token-providers\";\n\n// returns token from SSO token cache or ssoOidc.createToken() call.\nconst ssoToken = await fromSso();\n```\n\n## Token Provider Chain\n\n```ts\nimport { nodeProvider } from \"@aws-sdk/token-providers\";\n\n// returns token from default providers.\nconst token = await nodeProvider();\n```\n\n[http-bearer-auth-trait]: https://smithy.io/2.0/spec/authentication-traits.html#smithy-api-httpbearerauth-trait\n\n---\n\n### Development\n\nThis package contains a minimal copy of the SSO OIDC client, instead of relying on the full client, which\nwould cause a circular dependency.\n\nWhen regenerating the bundled version of the SSO OIDC client, run the esbuild.js script and then make the following changes:\n\n- Remove any dependency of the generated client on the credential chain such that it would create\n  a circular dependency back to this package. Because we only need the `CreateTokenCommand`, the client, and this command's\n  associated `Exception`s, it is possible to remove auth dependencies.\n- Ensure all required packages are declared in the `package.json` of token-providers.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{21/ca/203641cc2434c35f9d865ba34b3e8f6b8128cdd6dcc89bb94ee59daa69d1f9bd1ae23dd08bda0b5fb25afb92347740aa84485210b2ebfcaa9b200ee7002d → 62/22/1364c3e7c82fd6fae04872b8ba939c2037763baafb3266ad212a215f653beaca8d09d488c1f35949417960ce4dc938c217dd8cda61e60622b9c4e556c8e6}

@@ -11805,7 +11805,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "88-2ce256e94acc95bb",
+  "_rev": "89-229411b95611efd3",
   "_id": "@aws-sdk/middleware-stack",
   "readme": "# @aws-sdk/middleware-stack\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-stack/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-stack)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-stack.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-stack)\n\nThe package contains an implementation of middleware stack interface. Middleware\nstack is a structure storing middleware in specified order and resolve these\nmiddleware into a single handler.\n\nA middleware stack has five `Step`s, each of them represents a specific request life cycle:\n\n- **initialize**: The input is being prepared. Examples of typical initialization tasks include injecting default options computing derived parameters.\n\n- **serialize**: The input is complete and ready to be serialized. Examples of typical serialization tasks include input validation and building an HTTP request from user input.\n\n- **build**: The input has been serialized into an HTTP request, but that request may require further modification. Any request alterations will be applied to all retries. Examples of typical build tasks include injecting HTTP headers that describe a stable aspect of the request, such as `Content-Length` or a body checksum.\n\n- **finalizeRequest**: The request is being prepared to be sent over the wire. The request in this stage should already be semantically complete and should therefore only be altered to match the recipient's expectations. Examples of typical finalization tasks include request signing and injecting hop-by-hop headers.\n\n- **deserialize**: The response has arrived, the middleware here will deserialize the raw response object to structured response\n\n## Adding Middleware\n\nThere are two ways to add middleware to a middleware stack. They both add middleware to specified `Step` but they provide fine-grained location control differently.\n\n### Absolute Location\n\nYou can add middleware to specified step with:\n\n```javascript\nstack.add(middleware, {\n  step: \"finalizeRequest\",\n});\n```\n\nThis approach works for most cases. Sometimes you want your middleware to be executed in the front of the `Step`, you can set the `Priority` to `high`. Set the `Priority` to `low` then this middleware will be executed at the end of `Step`:\n\n```javascript\nstack.add(middleware, {\n  step: \"finalizeRequest\",\n  priority: \"high\",\n});\n```\n\nIf multiple middleware is added to same `step` with same `priority`, the order of them is determined by the order of adding them.\n\n### Relative Location\n\nIn some cases, you might want to execute your middleware before some other known middleware, then you can use `addRelativeTo()`:\n\n```javascript\nstack.add(middleware, {\n  step: \"finalizeRequest\",\n  name: \"myMiddleware\",\n});\nstack.addRelativeTo(anotherMiddleware, {\n  relation: \"before\", //or 'after'\n  toMiddleware: \"myMiddleware\",\n});\n```\n\n## Removing Middleware\n\nYou can remove middleware by name one at a time:\n\n```javascript\nstack.remove(\"Middleware1\");\n```\n\nIf you specify tags for middleware, you can remove multiple middleware at a time according to tag:\n\n```javascript\nstack.add(middleware, {\n  step: \"finalizeRequest\",\n  tags: [\"final\"],\n});\nstack.removeByTag(\"final\");\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{11/ce/cfe0306f434e54108cf07bbf961de2558039340fdb9c29220f6ec80d5fb0e2ecff9acb3b2e4847b2ed83fd96c1f298a75d2b042b0151b8e755a8643daa14 → 65/e7/8441a9da8f287d8dee84b12b3bb99779b51ba279d2e7102158525d9a95ac39cbd7b8ba690fd4d39d9181c7058be760e10a1c53fa26912d2df87f14fcf0db}

@@ -13869,7 +13869,7 @@
     "v7-legacy": "7.2.0",
     "legacy-v10": "10.4.5"
   },
-  "_rev": "2295-d4b27026e5c9ceb8",
+  "_rev": "2297-e9caa1d355d8100c",
   "_id": "glob",
   "readme": "# Glob\n\nMatch files using the patterns the shell uses.\n\nThe most correct and second fastest glob implementation in\nJavaScript. (See **Comparison to Other JavaScript Glob\nImplementations** at the bottom of this readme.)\n\n![a fun cartoon logo made of glob characters](https://github.com/isaacs/node-glob/raw/main/logo/glob.png)\n\n## Usage\n\nInstall with npm\n\n```\nnpm i glob\n```\n\n**Note** the npm package name is _not_ `node-glob` that's a\ndifferent thing that was abandoned years ago. Just `glob`.\n\n```js\n// load using import\nimport { glob, globSync, globStream, globStreamSync, Glob } from 'glob'\n// or using commonjs, that's fine, too\nconst {\n  glob,\n  globSync,\n  globStream,\n  globStreamSync,\n  Glob,\n} = require('glob')\n\n// the main glob() and globSync() resolve/return array of filenames\n\n// all js files, but don't look in node_modules\nconst jsfiles = await glob('**/*.js', { ignore: 'node_modules/**' })\n\n// pass in a signal to cancel the glob walk\nconst stopAfter100ms = await glob('**/*.css', {\n  signal: AbortSignal.timeout(100),\n})\n\n// multiple patterns supported as well\nconst images = await glob(['css/*.{png,jpeg}', 'public/*.{png,jpeg}'])\n\n// but of course you can do that with the glob pattern also\n// the sync function is the same, just returns a string[] instead\n// of Promise<string[]>\nconst imagesAlt = globSync('{css,public}/*.{png,jpeg}')\n\n// you can also stream them, this is a Minipass stream\nconst filesStream = globStream(['**/*.dat', 'logs/**/*.log'])\n\n// construct a Glob object if you wanna do it that way, which\n// allows for much faster walks if you have to look in the same\n// folder multiple times.\nconst g = new Glob('**/foo', {})\n// glob objects are async iterators, can also do globIterate() or\n// g.iterate(), same deal\nfor await (const file of g) {\n  console.log('found a foo file:', file)\n}\n// pass a glob as the glob options to reuse its settings and caches\nconst g2 = new Glob('**/bar', g)\n// sync iteration works as well\nfor (const file of g2) {\n  console.log('found a bar file:', file)\n}\n\n// you can also pass withFileTypes: true to get Path objects\n// these are like a Dirent, but with some more added powers\n// check out http://npm.im/path-scurry for more info on their API\nconst g3 = new Glob('**/baz/**', { withFileTypes: true })\ng3.stream().on('data', path => {\n  console.log(\n    'got a path object',\n    path.fullpath(),\n    path.isDirectory(),\n    path.readdirSync().map(e => e.name),\n  )\n})\n\n// if you use stat:true and withFileTypes, you can sort results\n// by things like modified time, filter by permission mode, etc.\n// All Stats fields will be available in that case. Slightly\n// slower, though.\n// For example:\nconst results = await glob('**', { stat: true, withFileTypes: true })\n\nconst timeSortedFiles = results\n  .sort((a, b) => a.mtimeMs - b.mtimeMs)\n  .map(path => path.fullpath())\n\nconst groupReadableFiles = results\n  .filter(path => path.mode & 0o040)\n  .map(path => path.fullpath())\n\n// custom ignores can be done like this, for example by saying\n// you'll ignore all markdown files, and all folders named 'docs'\nconst customIgnoreResults = await glob('**', {\n  ignore: {\n    ignored: p => /\\.md$/.test(p.name),\n    childrenIgnored: p => p.isNamed('docs'),\n  },\n})\n\n// another fun use case, only return files with the same name as\n// their parent folder, plus either `.ts` or `.js`\nconst folderNamedModules = await glob('**/*.{ts,js}', {\n  ignore: {\n    ignored: p => {\n      const pp = p.parent\n      return !(p.isNamed(pp.name + '.ts') || p.isNamed(pp.name + '.js'))\n    },\n  },\n})\n\n// find all files edited in the last hour, to do this, we ignore\n// all of them that are more than an hour old\nconst newFiles = await glob('**', {\n  // need stat so we have mtime\n  stat: true,\n  // only want the files, not the dirs\n  nodir: true,\n  ignore: {\n    ignored: p => {\n      return new Date() - p.mtime > 60 * 60 * 1000\n    },\n    // could add similar childrenIgnored here as well, but\n    // directory mtime is inconsistent across platforms, so\n    // probably better not to, unless you know the system\n    // tracks this reliably.\n  },\n})\n```\n\n**Note** Glob patterns should always use `/` as a path separator,\neven on Windows systems, as `\\` is used to escape glob\ncharacters. If you wish to use `\\` as a path separator _instead\nof_ using it as an escape character on Windows platforms, you may\nset `windowsPathsNoEscape:true` in the options. In this mode,\nspecial glob characters cannot be escaped, making it impossible\nto match a literal `*` `?` and so on in filenames.\n\n## Command Line Interface\n\n```\n$ glob -h\n\nUsage:\n  glob [options] [<pattern> [<pattern> ...]]\n\nExpand the positional glob expression arguments into any matching file system\npaths found.\n\n  -c<command> --cmd=<command>\n                         Run the command provided, passing the glob expression\n                         matches as arguments.\n\n  -A --all               By default, the glob cli command will not expand any\n                         arguments that are an exact match to a file on disk.\n\n                         This prevents double-expanding, in case the shell\n                         expands an argument whose filename is a glob\n                         expression.\n\n                         For example, if 'app/*.ts' would match 'app/[id].ts',\n                         then on Windows powershell or cmd.exe, 'glob app/*.ts'\n                         will expand to 'app/[id].ts', as expected. However, in\n                         posix shells such as bash or zsh, the shell will first\n                         expand 'app/*.ts' to a list of filenames. Then glob\n                         will look for a file matching 'app/[id].ts' (ie,\n                         'app/i.ts' or 'app/d.ts'), which is unexpected.\n\n                         Setting '--all' prevents this behavior, causing glob to\n                         treat ALL patterns as glob expressions to be expanded,\n                         even if they are an exact match to a file on disk.\n\n                         When setting this option, be sure to enquote arguments\n                         so that the shell will not expand them prior to passing\n                         them to the glob command process.\n\n  -a --absolute          Expand to absolute paths\n  -d --dot-relative      Prepend './' on relative matches\n  -m --mark              Append a / on any directories matched\n  -x --posix             Always resolve to posix style paths, using '/' as the\n                         directory separator, even on Windows. Drive letter\n                         absolute matches on Windows will be expanded to their\n                         full resolved UNC maths, eg instead of 'C:\\foo\\bar', it\n                         will expand to '//?/C:/foo/bar'.\n\n  -f --follow            Follow symlinked directories when expanding '**'\n  -R --realpath          Call 'fs.realpath' on all of the results. In the case\n                         of an entry that cannot be resolved, the entry is\n                         omitted. This incurs a slight performance penalty, of\n                         course, because of the added system calls.\n\n  -s --stat              Call 'fs.lstat' on all entries, whether required or not\n                         to determine if it's a valid match.\n\n  -b --match-base        Perform a basename-only match if the pattern does not\n                         contain any slash characters. That is, '*.js' would be\n                         treated as equivalent to '**/*.js', matching js files\n                         in all directories.\n\n  --dot                  Allow patterns to match files/directories that start\n                         with '.', even if the pattern does not start with '.'\n\n  --nobrace              Do not expand {...} patterns\n  --nocase               Perform a case-insensitive match. This defaults to\n                         'true' on macOS and Windows platforms, and false on all\n                         others.\n\n                         Note: 'nocase' should only be explicitly set when it is\n                         known that the filesystem's case sensitivity differs\n                         from the platform default. If set 'true' on\n                         case-insensitive file systems, then the walk may return\n                         more or less results than expected.\n\n  --nodir                Do not match directories, only files.\n\n                         Note: to *only* match directories, append a '/' at the\n                         end of the pattern.\n\n  --noext                Do not expand extglob patterns, such as '+(a|b)'\n  --noglobstar           Do not expand '**' against multiple path portions. Ie,\n                         treat it as a normal '*' instead.\n\n  --windows-path-no-escape\n                         Use '\\' as a path separator *only*, and *never* as an\n                         escape character. If set, all '\\' characters are\n                         replaced with '/' in the pattern.\n\n  -D<n> --max-depth=<n>  Maximum depth to traverse from the current working\n                         directory\n\n  -C<cwd> --cwd=<cwd>    Current working directory to execute/match in\n  -r<root> --root=<root> A string path resolved against the 'cwd', which is used\n                         as the starting point for absolute patterns that start\n                         with '/' (but not drive letters or UNC paths on\n                         Windows).\n\n                         Note that this *doesn't* necessarily limit the walk to\n                         the 'root' directory, and doesn't affect the cwd\n                         starting point for non-absolute patterns. A pattern\n                         containing '..' will still be able to traverse out of\n                         the root directory, if it is not an actual root\n                         directory on the filesystem, and any non-absolute\n                         patterns will still be matched in the 'cwd'.\n\n                         To start absolute and non-absolute patterns in the same\n                         path, you can use '--root=' to set it to the empty\n                         string. However, be aware that on Windows systems, a\n                         pattern like 'x:/*' or '//host/share/*' will *always*\n                         start in the 'x:/' or '//host/share/' directory,\n                         regardless of the --root setting.\n\n  --platform=<platform>  Defaults to the value of 'process.platform' if\n                         available, or 'linux' if not. Setting --platform=win32\n                         on non-Windows systems may cause strange behavior!\n\n  -i<ignore> --ignore=<ignore>\n                         Glob patterns to ignore Can be set multiple times\n  -v --debug             Output a huge amount of noisy debug information about\n                         patterns as they are parsed and used to match files.\n\n  -h --help              Show this usage information\n```\n\n## `glob(pattern: string | string[], options?: GlobOptions) => Promise<string[] | Path[]>`\n\nPerform an asynchronous glob search for the pattern(s) specified.\nReturns\n[Path](https://isaacs.github.io/path-scurry/classes/PathBase)\nobjects if the `withFileTypes` option is set to `true`. See below\nfor full options field desciptions.\n\n## `globSync(pattern: string | string[], options?: GlobOptions) => string[] | Path[]`\n\nSynchronous form of `glob()`.\n\nAlias: `glob.sync()`\n\n## `globIterate(pattern: string | string[], options?: GlobOptions) => AsyncGenerator<string>`\n\nReturn an async iterator for walking glob pattern matches.\n\nAlias: `glob.iterate()`\n\n## `globIterateSync(pattern: string | string[], options?: GlobOptions) => Generator<string>`\n\nReturn a sync iterator for walking glob pattern matches.\n\nAlias: `glob.iterate.sync()`, `glob.sync.iterate()`\n\n## `globStream(pattern: string | string[], options?: GlobOptions) => Minipass<string | Path>`\n\nReturn a stream that emits all the strings or `Path` objects and\nthen emits `end` when completed.\n\nAlias: `glob.stream()`\n\n## `globStreamSync(pattern: string | string[], options?: GlobOptions) => Minipass<string | Path>`\n\nSyncronous form of `globStream()`. Will read all the matches as\nfast as you consume them, even all in a single tick if you\nconsume them immediately, but will still respond to backpressure\nif they're not consumed immediately.\n\nAlias: `glob.stream.sync()`, `glob.sync.stream()`\n\n## `hasMagic(pattern: string | string[], options?: GlobOptions) => boolean`\n\nReturns `true` if the provided pattern contains any \"magic\" glob\ncharacters, given the options provided.\n\nBrace expansion is not considered \"magic\" unless the\n`magicalBraces` option is set, as brace expansion just turns one\nstring into an array of strings. So a pattern like `'x{a,b}y'`\nwould return `false`, because `'xay'` and `'xby'` both do not\ncontain any magic glob characters, and it's treated the same as\nif you had called it on `['xay', 'xby']`. When\n`magicalBraces:true` is in the options, brace expansion _is_\ntreated as a pattern having magic.\n\n## `escape(pattern: string, options?: GlobOptions) => string`\n\nEscape all magic characters in a glob pattern, so that it will\nonly ever match literal strings\n\nIf the `windowsPathsNoEscape` option is used, then characters are\nescaped by wrapping in `[]`, because a magic character wrapped in\na character class can only be satisfied by that exact character.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n## `unescape(pattern: string, options?: GlobOptions) => string`\n\nUn-escape a glob string that may contain some escaped characters.\n\nIf the `windowsPathsNoEscape` option is used, then square-brace\nescapes are removed, but not backslash escapes. For example, it\nwill turn the string `'[*]'` into `*`, but it will not turn\n`'\\\\*'` into `'*'`, because `\\` is a path separator in\n`windowsPathsNoEscape` mode.\n\nWhen `windowsPathsNoEscape` is not set, then both brace escapes\nand backslash escapes are removed.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n## Class `Glob`\n\nAn object that can perform glob pattern traversals.\n\n### `const g = new Glob(pattern: string | string[], options: GlobOptions)`\n\nOptions object is required.\n\nSee full options descriptions below.\n\nNote that a previous `Glob` object can be passed as the\n`GlobOptions` to another `Glob` instantiation to re-use settings\nand caches with a new pattern.\n\nTraversal functions can be called multiple times to run the walk\nagain.\n\n### `g.stream()`\n\nStream results asynchronously,\n\n### `g.streamSync()`\n\nStream results synchronously.\n\n### `g.iterate()`\n\nDefault async iteration function. Returns an AsyncGenerator that\niterates over the results.\n\n### `g.iterateSync()`\n\nDefault sync iteration function. Returns a Generator that\niterates over the results.\n\n### `g.walk()`\n\nReturns a Promise that resolves to the results array.\n\n### `g.walkSync()`\n\nReturns a results array.\n\n### Properties\n\nAll options are stored as properties on the `Glob` object.\n\n- `opts` The options provided to the constructor.\n- `patterns` An array of parsed immutable `Pattern` objects.\n\n## Options\n\nExported as `GlobOptions` TypeScript interface. A `GlobOptions`\nobject may be provided to any of the exported methods, and must\nbe provided to the `Glob` constructor.\n\nAll options are optional, boolean, and false by default, unless\notherwise noted.\n\nAll resolved options are added to the Glob object as properties.\n\nIf you are running many `glob` operations, you can pass a Glob\nobject as the `options` argument to a subsequent operation to\nshare the previously loaded cache.\n\n- `cwd` String path or `file://` string or URL object. The\n  current working directory in which to search. Defaults to\n  `process.cwd()`. See also: \"Windows, CWDs, Drive Letters, and\n  UNC Paths\", below.\n\n  This option may be either a string path or a `file://` URL\n  object or string.\n\n- `root` A string path resolved against the `cwd` option, which\n  is used as the starting point for absolute patterns that start\n  with `/`, (but not drive letters or UNC paths on Windows).\n\n  Note that this _doesn't_ necessarily limit the walk to the\n  `root` directory, and doesn't affect the cwd starting point for\n  non-absolute patterns. A pattern containing `..` will still be\n  able to traverse out of the root directory, if it is not an\n  actual root directory on the filesystem, and any non-absolute\n  patterns will be matched in the `cwd`. For example, the\n  pattern `/../*` with `{root:'/some/path'}` will return all\n  files in `/some`, not all files in `/some/path`. The pattern\n  `*` with `{root:'/some/path'}` will return all the entries in\n  the cwd, not the entries in `/some/path`.\n\n  To start absolute and non-absolute patterns in the same\n  path, you can use `{root:''}`. However, be aware that on\n  Windows systems, a pattern like `x:/*` or `//host/share/*` will\n  _always_ start in the `x:/` or `//host/share` directory,\n  regardless of the `root` setting.\n\n- `windowsPathsNoEscape` Use `\\\\` as a path separator _only_, and\n  _never_ as an escape character. If set, all `\\\\` characters are\n  replaced with `/` in the pattern.\n\n  Note that this makes it **impossible** to match against paths\n  containing literal glob pattern characters, but allows matching\n  with patterns constructed using `path.join()` and\n  `path.resolve()` on Windows platforms, mimicking the (buggy!)\n  behavior of Glob v7 and before on Windows. Please use with\n  caution, and be mindful of [the caveat below about Windows\n  paths](#windows). (For legacy reasons, this is also set if\n  `allowWindowsEscape` is set to the exact value `false`.)\n\n- `dot` Include `.dot` files in normal matches and `globstar`\n  matches. Note that an explicit dot in a portion of the pattern\n  will always match dot files.\n\n- `magicalBraces` Treat brace expansion like `{a,b}` as a \"magic\"\n  pattern. Has no effect if {@link nobrace} is set.\n\n  Only has effect on the {@link hasMagic} function, no effect on\n  glob pattern matching itself.\n\n- `dotRelative` Prepend all relative path strings with `./` (or\n  `.\\` on Windows).\n\n  Without this option, returned relative paths are \"bare\", so\n  instead of returning `'./foo/bar'`, they are returned as\n  `'foo/bar'`.\n\n  Relative patterns starting with `'../'` are not prepended with\n  `./`, even if this option is set.\n\n- `mark` Add a `/` character to directory matches. Note that this\n  requires additional stat calls.\n\n- `nobrace` Do not expand `{a,b}` and `{1..3}` brace sets.\n\n- `noglobstar` Do not match `**` against multiple filenames. (Ie,\n  treat it as a normal `*` instead.)\n\n- `noext` Do not match \"extglob\" patterns such as `+(a|b)`.\n\n- `nocase` Perform a case-insensitive match. This defaults to\n  `true` on macOS and Windows systems, and `false` on all others.\n\n  **Note** `nocase` should only be explicitly set when it is\n  known that the filesystem's case sensitivity differs from the\n  platform default. If set `true` on case-sensitive file\n  systems, or `false` on case-insensitive file systems, then the\n  walk may return more or less results than expected.\n\n- `maxDepth` Specify a number to limit the depth of the directory\n  traversal to this many levels below the `cwd`.\n\n- `matchBase` Perform a basename-only match if the pattern does\n  not contain any slash characters. That is, `*.js` would be\n  treated as equivalent to `**/*.js`, matching all js files in\n  all directories.\n\n- `nodir` Do not match directories, only files. (Note: to match\n  _only_ directories, put a `/` at the end of the pattern.)\n\n  Note: when `follow` and `nodir` are both set, then symbolic\n  links to directories are also omitted.\n\n- `stat` Call `lstat()` on all entries, whether required or not\n  to determine whether it's a valid match. When used with\n  `withFileTypes`, this means that matches will include data such\n  as modified time, permissions, and so on. Note that this will\n  incur a performance cost due to the added system calls.\n\n- `ignore` string or string[], or an object with `ignored` and\n  `childrenIgnored` methods.\n\n  If a string or string[] is provided, then this is treated as a\n  glob pattern or array of glob patterns to exclude from matches.\n  To ignore all children within a directory, as well as the entry\n  itself, append `'/**'` to the ignore pattern.\n\n  **Note** `ignore` patterns are _always_ in `dot:true` mode,\n  regardless of any other settings.\n\n  If an object is provided that has `ignored(path)` and/or\n  `childrenIgnored(path)` methods, then these methods will be\n  called to determine whether any Path is a match or if its\n  children should be traversed, respectively.\n\n- `follow` Follow symlinked directories when expanding `**`\n  patterns. This can result in a lot of duplicate references in\n  the presence of cyclic links, and make performance quite bad.\n\n  By default, a `**` in a pattern will follow 1 symbolic link if\n  it is not the first item in the pattern, or none if it is the\n  first item in the pattern, following the same behavior as Bash.\n\n  Note: when `follow` and `nodir` are both set, then symbolic\n  links to directories are also omitted.\n\n- `realpath` Set to true to call `fs.realpath` on all of the\n  results. In the case of an entry that cannot be resolved, the\n  entry is omitted. This incurs a slight performance penalty, of\n  course, because of the added system calls.\n\n- `absolute` Set to true to always receive absolute paths for\n  matched files. Set to `false` to always receive relative paths\n  for matched files.\n\n  By default, when this option is not set, absolute paths are\n  returned for patterns that are absolute, and otherwise paths\n  are returned that are relative to the `cwd` setting.\n\n  This does _not_ make an extra system call to get the realpath,\n  it only does string path resolution.\n\n  `absolute` may not be used along with `withFileTypes`.\n\n- `posix` Set to true to use `/` as the path separator in\n  returned results. On posix systems, this has no effect. On\n  Windows systems, this will return `/` delimited path results,\n  and absolute paths will be returned in their full resolved UNC\n  path form, eg insted of `'C:\\\\foo\\\\bar'`, it will return\n  `//?/C:/foo/bar`.\n\n- `platform` Defaults to value of `process.platform` if\n  available, or `'linux'` if not. Setting `platform:'win32'` on\n  non-Windows systems may cause strange behavior.\n\n- `withFileTypes` Return [PathScurry](http://npm.im/path-scurry)\n  `Path` objects instead of strings. These are similar to a\n  NodeJS `Dirent` object, but with additional methods and\n  properties.\n\n  `withFileTypes` may not be used along with `absolute`.\n\n- `signal` An AbortSignal which will cancel the Glob walk when\n  triggered.\n\n- `fs` An override object to pass in custom filesystem methods.\n  See [PathScurry docs](http://npm.im/path-scurry) for what can\n  be overridden.\n\n- `scurry` A [PathScurry](http://npm.im/path-scurry) object used\n  to traverse the file system. If the `nocase` option is set\n  explicitly, then any provided `scurry` object must match this\n  setting.\n\n- `includeChildMatches` boolean, default `true`. Do not match any\n  children of any matches. For example, the pattern `**\\/foo`\n  would match `a/foo`, but not `a/foo/b/foo` in this mode.\n\n  This is especially useful for cases like \"find all\n  `node_modules` folders, but not the ones in `node_modules`\".\n\n  In order to support this, the `Ignore` implementation must\n  support an `add(pattern: string)` method. If using the default\n  `Ignore` class, then this is fine, but if this is set to\n  `false`, and a custom `Ignore` is provided that does not have\n  an `add()` method, then it will throw an error.\n\n  **Caveat** It _only_ ignores matches that would be a descendant\n  of a previous match, and only if that descendant is matched\n  _after_ the ancestor is encountered. Since the file system walk\n  happens in indeterminate order, it's possible that a match will\n  already be added before its ancestor, if multiple or braced\n  patterns are used.\n\n  For example:\n\n  ```js\n  const results = await glob(\n    [\n      // likely to match first, since it's just a stat\n      'a/b/c/d/e/f',\n\n      // this pattern is more complicated! It must to various readdir()\n      // calls and test the results against a regular expression, and that\n      // is certainly going to take a little bit longer.\n      //\n      // So, later on, it encounters a match at 'a/b/c/d/e', but it's too\n      // late to ignore a/b/c/d/e/f, because it's already been emitted.\n      'a/[bdf]/?/[a-z]/*',\n    ],\n    { includeChildMatches: false },\n  )\n  ```\n\n  It's best to only set this to `false` if you can be reasonably\n  sure that no components of the pattern will potentially match\n  one another's file system descendants, or if the occasional\n  included child entry will not cause problems.\n\n## Glob Primer\n\nMuch more information about glob pattern expansion can be found\nby running `man bash` and searching for `Pattern Matching`.\n\n\"Globs\" are the patterns you type when you do stuff like `ls\n*.js` on the command line, or put `build/*` in a `.gitignore`\nfile.\n\nBefore parsing the path part patterns, braced sections are\nexpanded into a set. Braced sections start with `{` and end with\n`}`, with 2 or more comma-delimited sections within. Braced\nsections may contain slash characters, so `a{/b/c,bcd}` would\nexpand into `a/b/c` and `abcd`.\n\nThe following characters have special magic meaning when used in\na path portion. With the exception of `**`, none of these match\npath separators (ie, `/` on all platforms, and `\\` on Windows).\n\n- `*` Matches 0 or more characters in a single path portion.\n  When alone in a path portion, it must match at least 1\n  character. If `dot:true` is not specified, then `*` will not\n  match against a `.` character at the start of a path portion.\n- `?` Matches 1 character. If `dot:true` is not specified, then\n  `?` will not match against a `.` character at the start of a\n  path portion.\n- `[...]` Matches a range of characters, similar to a RegExp\n  range. If the first character of the range is `!` or `^` then\n  it matches any character not in the range. If the first\n  character is `]`, then it will be considered the same as `\\]`,\n  rather than the end of the character class.\n- `!(pattern|pattern|pattern)` Matches anything that does not\n  match any of the patterns provided. May _not_ contain `/`\n  characters. Similar to `*`, if alone in a path portion, then\n  the path portion must have at least one character.\n- `?(pattern|pattern|pattern)` Matches zero or one occurrence of\n  the patterns provided. May _not_ contain `/` characters.\n- `+(pattern|pattern|pattern)` Matches one or more occurrences of\n  the patterns provided. May _not_ contain `/` characters.\n- `*(a|b|c)` Matches zero or more occurrences of the patterns\n  provided. May _not_ contain `/` characters.\n- `@(pattern|pat*|pat?erN)` Matches exactly one of the patterns\n  provided. May _not_ contain `/` characters.\n- `**` If a \"globstar\" is alone in a path portion, then it\n  matches zero or more directories and subdirectories searching\n  for matches. It does not crawl symlinked directories, unless\n  `{follow:true}` is passed in the options object. A pattern\n  like `a/b/**` will only match `a/b` if it is a directory.\n  Follows 1 symbolic link if not the first item in the pattern,\n  or 0 if it is the first item, unless `follow:true` is set, in\n  which case it follows all symbolic links.\n\n`[:class:]` patterns are supported by this implementation, but\n`[=c=]` and `[.symbol.]` style class patterns are not.\n\n### Dots\n\nIf a file or directory path portion has a `.` as the first\ncharacter, then it will not match any glob pattern unless that\npattern's corresponding path part also has a `.` as its first\ncharacter.\n\nFor example, the pattern `a/.*/c` would match the file at\n`a/.b/c`. However the pattern `a/*/c` would not, because `*` does\nnot start with a dot character.\n\nYou can make glob treat dots as normal characters by setting\n`dot:true` in the options.\n\n### Basename Matching\n\nIf you set `matchBase:true` in the options, and the pattern has\nno slashes in it, then it will seek for any file anywhere in the\ntree with a matching basename. For example, `*.js` would match\n`test/simple/basic.js`.\n\n### Empty Sets\n\nIf no matching files are found, then an empty array is returned.\nThis differs from the shell, where the pattern itself is\nreturned. For example:\n\n```sh\n$ echo a*s*d*f\na*s*d*f\n```\n\n## Comparisons to other fnmatch/glob implementations\n\nWhile strict compliance with the existing standards is a\nworthwhile goal, some discrepancies exist between node-glob and\nother implementations, and are intentional.\n\nThe double-star character `**` is supported by default, unless\nthe `noglobstar` flag is set. This is supported in the manner of\nbsdglob and bash 5, where `**` only has special significance if\nit is the only thing in a path part. That is, `a/**/b` will match\n`a/x/y/b`, but `a/**b` will not.\n\nNote that symlinked directories are not traversed as part of a\n`**`, though their contents may match against subsequent portions\nof the pattern. This prevents infinite loops and duplicates and\nthe like. You can force glob to traverse symlinks with `**` by\nsetting `{follow:true}` in the options.\n\nThere is no equivalent of the `nonull` option. A pattern that\ndoes not find any matches simply resolves to nothing. (An empty\narray, immediately ended stream, etc.)\n\nIf brace expansion is not disabled, then it is performed before\nany other interpretation of the glob pattern. Thus, a pattern\nlike `+(a|{b),c)}`, which would not be valid in bash or zsh, is\nexpanded **first** into the set of `+(a|b)` and `+(a|c)`, and\nthose patterns are checked for validity. Since those two are\nvalid, matching proceeds.\n\nThe character class patterns `[:class:]` (posix standard named\nclasses) style class patterns are supported and unicode-aware,\nbut `[=c=]` (locale-specific character collation weight), and\n`[.symbol.]` (collating symbol), are not.\n\n### Repeated Slashes\n\nUnlike Bash and zsh, repeated `/` are always coalesced into a\nsingle path separator.\n\n### Comments and Negation\n\nPreviously, this module let you mark a pattern as a \"comment\" if\nit started with a `#` character, or a \"negated\" pattern if it\nstarted with a `!` character.\n\nThese options were deprecated in version 5, and removed in\nversion 6.\n\nTo specify things that should not match, use the `ignore` option.\n\n## Windows\n\n**Please only use forward-slashes in glob expressions.**\n\nThough windows uses either `/` or `\\` as its path separator, only\n`/` characters are used by this glob implementation. You must use\nforward-slashes **only** in glob expressions. Back-slashes will\nalways be interpreted as escape characters, not path separators.\n\nResults from absolute patterns such as `/foo/*` are mounted onto\nthe root setting using `path.join`. On windows, this will by\ndefault result in `/foo/*` matching `C:\\foo\\bar.txt`.\n\nTo automatically coerce all `\\` characters to `/` in pattern\nstrings, **thus making it impossible to escape literal glob\ncharacters**, you may set the `windowsPathsNoEscape` option to\n`true`.\n\n### Windows, CWDs, Drive Letters, and UNC Paths\n\nOn posix systems, when a pattern starts with `/`, any `cwd`\noption is ignored, and the traversal starts at `/`, plus any\nnon-magic path portions specified in the pattern.\n\nOn Windows systems, the behavior is similar, but the concept of\nan \"absolute path\" is somewhat more involved.\n\n#### UNC Paths\n\nA UNC path may be used as the start of a pattern on Windows\nplatforms. For example, a pattern like: `//?/x:/*` will return\nall file entries in the root of the `x:` drive. A pattern like\n`//ComputerName/Share/*` will return all files in the associated\nshare.\n\nUNC path roots are always compared case insensitively.\n\n#### Drive Letters\n\nA pattern starting with a drive letter, like `c:/*`, will search\nin that drive, regardless of any `cwd` option provided.\n\nIf the pattern starts with `/`, and is not a UNC path, and there\nis an explicit `cwd` option set with a drive letter, then the\ndrive letter in the `cwd` is used as the root of the directory\ntraversal.\n\nFor example, `glob('/tmp', { cwd: 'c:/any/thing' })` will return\n`['c:/tmp']` as the result.\n\nIf an explicit `cwd` option is not provided, and the pattern\nstarts with `/`, then the traversal will run on the root of the\ndrive provided as the `cwd` option. (That is, it is the result of\n`path.resolve('/')`.)\n\n## Race Conditions\n\nGlob searching, by its very nature, is susceptible to race\nconditions, since it relies on directory walking.\n\nAs a result, it is possible that a file that exists when glob\nlooks for it may have been deleted or modified by the time it\nreturns the result.\n\nBy design, this implementation caches all readdir calls that it\nmakes, in order to cut down on system overhead. However, this\nalso makes it even more susceptible to races, especially if the\ncache object is reused between glob calls.\n\nUsers are thus advised not to use a glob result as a guarantee of\nfilesystem state in the face of rapid changes. For the vast\nmajority of operations, this is never a problem.\n\n### See Also:\n\n- `man sh`\n- `man bash` [Pattern\n  Matching](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html)\n- `man 3 fnmatch`\n- `man 5 gitignore`\n- [minimatch documentation](https://github.com/isaacs/minimatch)\n\n## Glob Logo\n\nGlob's logo was created by [Tanya\nBrassie](http://tanyabrassie.com/). Logo files can be found\n[here](https://github.com/isaacs/node-glob/tree/master/logo).\n\nThe logo is licensed under a [Creative Commons\nAttribution-ShareAlike 4.0 International\nLicense](https://creativecommons.org/licenses/by-sa/4.0/).\n\n## Contributing\n\nAny change to behavior (including bugfixes) must come with a\ntest.\n\nPatches that fail tests or reduce performance will be rejected.\n\n```sh\n# to run tests\nnpm test\n\n# to re-generate test fixtures\nnpm run test-regen\n\n# run the benchmarks\nnpm run bench\n\n# to profile javascript\nnpm run prof\n```\n\n## Comparison to Other JavaScript Glob Implementations\n\n**tl;dr**\n\n- If you want glob matching that is as faithful as possible to\n  Bash pattern expansion semantics, and as fast as possible\n  within that constraint, _use this module_.\n- If you are reasonably sure that the patterns you will encounter\n  are relatively simple, and want the absolutely fastest glob\n  matcher out there, _use [fast-glob](http://npm.im/fast-glob)_.\n- If you are reasonably sure that the patterns you will encounter\n  are relatively simple, and want the convenience of\n  automatically respecting `.gitignore` files, _use\n  [globby](http://npm.im/globby)_.\n\nThere are some other glob matcher libraries on npm, but these\nthree are (in my opinion, as of 2023) the best.\n\n---\n\n**full explanation**\n\nEvery library reflects a set of opinions and priorities in the\ntrade-offs it makes. Other than this library, I can personally\nrecommend both [globby](http://npm.im/globby) and\n[fast-glob](http://npm.im/fast-glob), though they differ in their\nbenefits and drawbacks.\n\nBoth have very nice APIs and are reasonably fast.\n\n`fast-glob` is, as far as I am aware, the fastest glob\nimplementation in JavaScript today. However, there are many\ncases where the choices that `fast-glob` makes in pursuit of\nspeed mean that its results differ from the results returned by\nBash and other sh-like shells, which may be surprising.\n\nIn my testing, `fast-glob` is around 10-20% faster than this\nmodule when walking over 200k files nested 4 directories\ndeep[1](#fn-webscale). However, there are some inconsistencies\nwith Bash matching behavior that this module does not suffer\nfrom:\n\n- `**` only matches files, not directories\n- `..` path portions are not handled unless they appear at the\n  start of the pattern\n- `./!(<pattern>)` will not match any files that _start_ with\n  `<pattern>`, even if they do not match `<pattern>`. For\n  example, `!(9).txt` will not match `9999.txt`.\n- Some brace patterns in the middle of a pattern will result in\n  failing to find certain matches.\n- Extglob patterns are allowed to contain `/` characters.\n\nGlobby exhibits all of the same pattern semantics as fast-glob,\n(as it is a wrapper around fast-glob) and is slightly slower than\nnode-glob (by about 10-20% in the benchmark test set, or in other\nwords, anywhere from 20-50% slower than fast-glob). However, it\nadds some API conveniences that may be worth the costs.\n\n- Support for `.gitignore` and other ignore files.\n- Support for negated globs (ie, patterns starting with `!`\n  rather than using a separate `ignore` option).\n\nThe priority of this module is \"correctness\" in the sense of\nperforming a glob pattern expansion as faithfully as possible to\nthe behavior of Bash and other sh-like shells, with as much speed\nas possible.\n\nNote that prior versions of `node-glob` are _not_ on this list.\nFormer versions of this module are far too slow for any cases\nwhere performance matters at all, and were designed with APIs\nthat are extremely dated by current JavaScript standards.\n\n---\n\n<small id=\"fn-webscale\">[1]: In the cases where this module\nreturns results and `fast-glob` doesn't, it's even faster, of\ncourse.</small>\n\n![lumpy space princess saying 'oh my GLOB'](https://github.com/isaacs/node-glob/raw/main/oh-my-glob.gif)\n\n### Benchmark Results\n\nFirst number is time, smaller is better.\n\nSecond number is the count of results returned.\n\n```\n--- pattern: '**' ---\n~~ sync ~~\nnode fast-glob sync             0m0.598s  200364\nnode globby sync                0m0.765s  200364\nnode current globSync mjs       0m0.683s  222656\nnode current glob syncStream    0m0.649s  222656\n~~ async ~~\nnode fast-glob async            0m0.350s  200364\nnode globby async               0m0.509s  200364\nnode current glob async mjs     0m0.463s  222656\nnode current glob stream        0m0.411s  222656\n\n--- pattern: '**/..' ---\n~~ sync ~~\nnode fast-glob sync             0m0.486s  0\nnode globby sync                0m0.769s  200364\nnode current globSync mjs       0m0.564s  2242\nnode current glob syncStream    0m0.583s  2242\n~~ async ~~\nnode fast-glob async            0m0.283s  0\nnode globby async               0m0.512s  200364\nnode current glob async mjs     0m0.299s  2242\nnode current glob stream        0m0.312s  2242\n\n--- pattern: './**/0/**/0/**/0/**/0/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.490s  10\nnode globby sync                0m0.517s  10\nnode current globSync mjs       0m0.540s  10\nnode current glob syncStream    0m0.550s  10\n~~ async ~~\nnode fast-glob async            0m0.290s  10\nnode globby async               0m0.296s  10\nnode current glob async mjs     0m0.278s  10\nnode current glob stream        0m0.302s  10\n\n--- pattern: './**/[01]/**/[12]/**/[23]/**/[45]/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.500s  160\nnode globby sync                0m0.528s  160\nnode current globSync mjs       0m0.556s  160\nnode current glob syncStream    0m0.573s  160\n~~ async ~~\nnode fast-glob async            0m0.283s  160\nnode globby async               0m0.301s  160\nnode current glob async mjs     0m0.306s  160\nnode current glob stream        0m0.322s  160\n\n--- pattern: './**/0/**/0/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.502s  5230\nnode globby sync                0m0.527s  5230\nnode current globSync mjs       0m0.544s  5230\nnode current glob syncStream    0m0.557s  5230\n~~ async ~~\nnode fast-glob async            0m0.285s  5230\nnode globby async               0m0.305s  5230\nnode current glob async mjs     0m0.304s  5230\nnode current glob stream        0m0.310s  5230\n\n--- pattern: '**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.580s  200023\nnode globby sync                0m0.771s  200023\nnode current globSync mjs       0m0.685s  200023\nnode current glob syncStream    0m0.649s  200023\n~~ async ~~\nnode fast-glob async            0m0.349s  200023\nnode globby async               0m0.509s  200023\nnode current glob async mjs     0m0.427s  200023\nnode current glob stream        0m0.388s  200023\n\n--- pattern: '{**/*.txt,**/?/**/*.txt,**/?/**/?/**/*.txt,**/?/**/?/**/?/**/*.txt,**/?/**/?/**/?/**/?/**/*.txt}' ---\n~~ sync ~~\nnode fast-glob sync             0m0.589s  200023\nnode globby sync                0m0.771s  200023\nnode current globSync mjs       0m0.716s  200023\nnode current glob syncStream    0m0.684s  200023\n~~ async ~~\nnode fast-glob async            0m0.351s  200023\nnode globby async               0m0.518s  200023\nnode current glob async mjs     0m0.462s  200023\nnode current glob stream        0m0.468s  200023\n\n--- pattern: '**/5555/0000/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.496s  1000\nnode globby sync                0m0.519s  1000\nnode current globSync mjs       0m0.539s  1000\nnode current glob syncStream    0m0.567s  1000\n~~ async ~~\nnode fast-glob async            0m0.285s  1000\nnode globby async               0m0.299s  1000\nnode current glob async mjs     0m0.305s  1000\nnode current glob stream        0m0.301s  1000\n\n--- pattern: './**/0/**/../[01]/**/0/../**/0/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.484s  0\nnode globby sync                0m0.507s  0\nnode current globSync mjs       0m0.577s  4880\nnode current glob syncStream    0m0.586s  4880\n~~ async ~~\nnode fast-glob async            0m0.280s  0\nnode globby async               0m0.298s  0\nnode current glob async mjs     0m0.327s  4880\nnode current glob stream        0m0.324s  4880\n\n--- pattern: '**/????/????/????/????/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.547s  100000\nnode globby sync                0m0.673s  100000\nnode current globSync mjs       0m0.626s  100000\nnode current glob syncStream    0m0.618s  100000\n~~ async ~~\nnode fast-glob async            0m0.315s  100000\nnode globby async               0m0.414s  100000\nnode current glob async mjs     0m0.366s  100000\nnode current glob stream        0m0.345s  100000\n\n--- pattern: './{**/?{/**/?{/**/?{/**/?,,,,},,,,},,,,},,,}/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.588s  100000\nnode globby sync                0m0.670s  100000\nnode current globSync mjs       0m0.717s  200023\nnode current glob syncStream    0m0.687s  200023\n~~ async ~~\nnode fast-glob async            0m0.343s  100000\nnode globby async               0m0.418s  100000\nnode current glob async mjs     0m0.519s  200023\nnode current glob stream        0m0.451s  200023\n\n--- pattern: '**/!(0|9).txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.573s  160023\nnode globby sync                0m0.731s  160023\nnode current globSync mjs       0m0.680s  180023\nnode current glob syncStream    0m0.659s  180023\n~~ async ~~\nnode fast-glob async            0m0.345s  160023\nnode globby async               0m0.476s  160023\nnode current glob async mjs     0m0.427s  180023\nnode current glob stream        0m0.388s  180023\n\n--- pattern: './{*/**/../{*/**/../{*/**/../{*/**/../{*/**,,,,},,,,},,,,},,,,},,,,}/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.483s  0\nnode globby sync                0m0.512s  0\nnode current globSync mjs       0m0.811s  200023\nnode current glob syncStream    0m0.773s  200023\n~~ async ~~\nnode fast-glob async            0m0.280s  0\nnode globby async               0m0.299s  0\nnode current glob async mjs     0m0.617s  200023\nnode current glob stream        0m0.568s  200023\n\n--- pattern: './*/**/../*/**/../*/**/../*/**/../*/**/../*/**/../*/**/../*/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.485s  0\nnode globby sync                0m0.507s  0\nnode current globSync mjs       0m0.759s  200023\nnode current glob syncStream    0m0.740s  200023\n~~ async ~~\nnode fast-glob async            0m0.281s  0\nnode globby async               0m0.297s  0\nnode current glob async mjs     0m0.544s  200023\nnode current glob stream        0m0.464s  200023\n\n--- pattern: './*/**/../*/**/../*/**/../*/**/../*/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.486s  0\nnode globby sync                0m0.513s  0\nnode current globSync mjs       0m0.734s  200023\nnode current glob syncStream    0m0.696s  200023\n~~ async ~~\nnode fast-glob async            0m0.286s  0\nnode globby async               0m0.296s  0\nnode current glob async mjs     0m0.506s  200023\nnode current glob stream        0m0.483s  200023\n\n--- pattern: './0/**/../1/**/../2/**/../3/**/../4/**/../5/**/../6/**/../7/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.060s  0\nnode globby sync                0m0.074s  0\nnode current globSync mjs       0m0.067s  0\nnode current glob syncStream    0m0.066s  0\n~~ async ~~\nnode fast-glob async            0m0.060s  0\nnode globby async               0m0.075s  0\nnode current glob async mjs     0m0.066s  0\nnode current glob stream        0m0.067s  0\n\n--- pattern: './**/?/**/?/**/?/**/?/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.568s  100000\nnode globby sync                0m0.651s  100000\nnode current globSync mjs       0m0.619s  100000\nnode current glob syncStream    0m0.617s  100000\n~~ async ~~\nnode fast-glob async            0m0.332s  100000\nnode globby async               0m0.409s  100000\nnode current glob async mjs     0m0.372s  100000\nnode current glob stream        0m0.351s  100000\n\n--- pattern: '**/*/**/*/**/*/**/*/**' ---\n~~ sync ~~\nnode fast-glob sync             0m0.603s  200113\nnode globby sync                0m0.798s  200113\nnode current globSync mjs       0m0.730s  222137\nnode current glob syncStream    0m0.693s  222137\n~~ async ~~\nnode fast-glob async            0m0.356s  200113\nnode globby async               0m0.525s  200113\nnode current glob async mjs     0m0.508s  222137\nnode current glob stream        0m0.455s  222137\n\n--- pattern: './**/*/**/*/**/*/**/*/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.622s  200000\nnode globby sync                0m0.792s  200000\nnode current globSync mjs       0m0.722s  200000\nnode current glob syncStream    0m0.695s  200000\n~~ async ~~\nnode fast-glob async            0m0.369s  200000\nnode globby async               0m0.527s  200000\nnode current glob async mjs     0m0.502s  200000\nnode current glob stream        0m0.481s  200000\n\n--- pattern: '**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.588s  200023\nnode globby sync                0m0.771s  200023\nnode current globSync mjs       0m0.684s  200023\nnode current glob syncStream    0m0.658s  200023\n~~ async ~~\nnode fast-glob async            0m0.352s  200023\nnode globby async               0m0.516s  200023\nnode current glob async mjs     0m0.432s  200023\nnode current glob stream        0m0.384s  200023\n\n--- pattern: './**/**/**/**/**/**/**/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.589s  200023\nnode globby sync                0m0.766s  200023\nnode current globSync mjs       0m0.682s  200023\nnode current glob syncStream    0m0.652s  200023\n~~ async ~~\nnode fast-glob async            0m0.352s  200023\nnode globby async               0m0.523s  200023\nnode current glob async mjs     0m0.436s  200023\nnode current glob stream        0m0.380s  200023\n\n--- pattern: '**/*/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.592s  200023\nnode globby sync                0m0.776s  200023\nnode current globSync mjs       0m0.691s  200023\nnode current glob syncStream    0m0.659s  200023\n~~ async ~~\nnode fast-glob async            0m0.357s  200023\nnode globby async               0m0.513s  200023\nnode current glob async mjs     0m0.471s  200023\nnode current glob stream        0m0.424s  200023\n\n--- pattern: '**/*/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.585s  200023\nnode globby sync                0m0.766s  200023\nnode current globSync mjs       0m0.694s  200023\nnode current glob syncStream    0m0.664s  200023\n~~ async ~~\nnode fast-glob async            0m0.350s  200023\nnode globby async               0m0.514s  200023\nnode current glob async mjs     0m0.472s  200023\nnode current glob stream        0m0.424s  200023\n\n--- pattern: '**/[0-9]/**/*.txt' ---\n~~ sync ~~\nnode fast-glob sync             0m0.544s  100000\nnode globby sync                0m0.636s  100000\nnode current globSync mjs       0m0.626s  100000\nnode current glob syncStream    0m0.621s  100000\n~~ async ~~\nnode fast-glob async            0m0.322s  100000\nnode globby async               0m0.404s  100000\nnode current glob async mjs     0m0.360s  100000\nnode current glob stream        0m0.352s  100000\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0a/0d/f1596ed12b2c73bc3dac103f9a36395d4743bed55623d3a202c949d55746b13f05b8d7703ac72fdc500d8c27dceca9e7ec7260b8541536b7fb0f36547931 → 6a/9a/63e910bf36172199638d3bedcbca850013691323115a65794ca9a528c11a0d9db251d477c1bd921f37fb8d86b87656fa4929d28bf7537866fa05dd8b8630}

@@ -5126,7 +5126,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "83-3e0bc9cde3dd4233",
+  "_rev": "84-49b88b174ee86876",
   "_id": "@aws-sdk/util-body-length-browser",
   "readme": "# @aws-sdk/util-body-length-browser\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-body-length-browser/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-body-length-browser)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-body-length-browser.svg)](https://www.npmjs.com/package/@aws-sdk/util-body-length-browser)\n\nDetermines the length of a request body in browsers\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{a6/80/958fa30ce87917d8fa2972ee4b2d55ff76c7923fdc28f5aab426a28de8ba86de06a8424214932e41550cc932a92583e31c60216333695116657dc98671e9 → 6d/1c/3c1f0de6f8cce03048ecb008352401ba3be3c679406f9d48b2d6f587e8d316d7d3564f4649eafe36a67c92a10e30e0e9eaa8153330bfd848d327f202ddda}

@@ -47017,7 +47017,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "3.5.1-rc.0"
   },
-  "_rev": "97-4d9c3dee4de22edf",
+  "_rev": "98-bf12bdf645d510d7",
   "_id": "@aws-sdk/credential-provider-node",
   "readme": "# @aws-sdk/credential-provider-node\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/credential-provider-node/latest.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-node)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/credential-provider-node.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-node)\n\n## AWS Credential Provider for Node.JS\n\nThis module provides a factory function, `defaultProvider`, that will attempt to\nsource AWS credentials from a Node.JS environment. It will attempt to find\ncredentials from the following sources (listed in order of precedence):\n\n- Environment variables exposed via `process.env`\n- SSO credentials from token cache\n- Web identity token credentials\n- Shared credentials and config ini files\n- The EC2/ECS Instance Metadata Service\n\nThe default credential provider will invoke one provider at a time and only\ncontinue to the next if no credentials have been located. For example, if the\nprocess finds values defined via the `AWS_ACCESS_KEY_ID` and\n`AWS_SECRET_ACCESS_KEY` environment variables, the files at `~/.aws/credentials`\nand `~/.aws/config` will not be read, nor will any messages be sent to the\nInstance Metadata Service.\n\nIf invalid configuration is encountered (such as a profile in\n`~/.aws/credentials` specifying as its `source_profile` the name of a profile\nthat does not exist), then the chained provider will be rejected with an error\nand will not invoke the next provider in the list.\n\n_IMPORTANT_: if you intend to acquire credentials using EKS \n[IAM Roles for Service Accounts](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html), \nthen you must explicitly specify a value for `roleAssumerWithWebIdentity`. There is a\ndefault function available in `@aws-sdk/client-sts` package. An example of using\nthis:\n\n```js\nconst { getDefaultRoleAssumerWithWebIdentity } = require(\"@aws-sdk/client-sts\");\nconst { defaultProvider } = require(\"@aws-sdk/credential-provider-node\");\nconst { S3Client, GetObjectCommand } = require(\"@aws-sdk/client-s3\");\n\nconst provider = defaultProvider({\n  roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity({\n    // You must explicitly pass a region if you are not using us-east-1\n    region: \"eu-west-1\"\n  }),\n});\n\nconst client = new S3Client({ credentialDefaultProvider: provider });\n```\n\n_IMPORTANT_: We provide a wrapper of this provider in `@aws-sdk/credential-providers`\npackage to save you from importing `getDefaultRoleAssumerWithWebIdentity()` or\n`getDefaultRoleAssume()` from STS package. Similarly, you can do:\n\n```js\nconst { fromNodeProviderChain } = require(\"@aws-sdk/credential-providers\");\n\nconst credentials = fromNodeProviderChain();\n\nconst client = new S3Client({ credentials });\n```\n\n## Supported configuration\n\nYou may customize how credentials are resolved by providing an options hash to\nthe `defaultProvider` factory function. The following options are\nsupported:\n\n- `profile` - The configuration profile to use. If not specified, the provider\n  will use the value in the `AWS_PROFILE` environment variable or a default of\n  `default`.\n- `filepath` - The path to the shared credentials file. If not specified, the\n  provider will use the value in the `AWS_SHARED_CREDENTIALS_FILE` environment\n  variable or a default of `~/.aws/credentials`.\n- `configFilepath` - The path to the shared config file. If not specified, the\n  provider will use the value in the `AWS_CONFIG_FILE` environment variable or a\n  default of `~/.aws/config`.\n- `mfaCodeProvider` - A function that returns a a promise fulfilled with an\n  MFA token code for the provided MFA Serial code. If a profile requires an MFA\n  code and `mfaCodeProvider` is not a valid function, the credential provider\n  promise will be rejected.\n- `roleAssumer` - A function that assumes a role and returns a promise\n  fulfilled with credentials for the assumed role. If not specified, no role\n  will be assumed, and an error will be thrown.\n- `roleArn` - ARN to assume. If not specified, the provider will use the value\n  in the `AWS_ROLE_ARN` environment variable.\n- `webIdentityTokenFile` - File location of where the `OIDC` token is stored.\n  If not specified, the provider will use the value in the `AWS_WEB_IDENTITY_TOKEN_FILE`\n  environment variable.\n- `roleAssumerWithWebIdentity` - A function that assumes a role with web identity and\n  returns a promise fulfilled with credentials for the assumed role.\n- `timeout` - The connection timeout (in milliseconds) to apply to any remote\n  requests. If not specified, a default value of `1000` (one second) is used.\n- `maxRetries` - The maximum number of times any HTTP connections should be\n  retried. If not specified, a default value of `0` will be used.\n\n## Related packages:\n\n- [AWS Credential Provider for Node.JS - Environment Variables](../credential-provider-env)\n- [AWS Credential Provider for Node.JS - SSO](../credential-provider-sso)\n- [AWS Credential Provider for Node.JS - Web Identity](../credential-provider-web-identity)\n- [AWS Credential Provider for Node.JS - Shared Configuration Files](../credential-provider-ini)\n- [AWS Credential Provider for Node.JS - Instance and Container Metadata](../credential-provider-imds)\n- [AWS Shared Configuration File Loader](../shared-ini-file-loader)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{f4/7c/1904b337bc96eec81360f6b092866804990110ea62c7b6f3a0f27ae83abd45de84a604f8df69013b772f9eabe035b43da96be92dbefbeefc7e3cb414ad6e → 6d/3d/4da2eca3afae8e5985b522d5ceaf2f2eea44daa84475df86dcb7a56c1c7d7dda219c7ef030757560fa66db5000db97875959c9e5060e28600e25b5734b02}

@@ -286,7 +286,7 @@
   "dist-tags": {
     "latest": "0.0.2"
   },
-  "_rev": "1703-fa23775b9185c287",
+  "_rev": "1704-d85248c2cf0ecd9a",
   "_id": "concat-map",
   "readme": "# concat-map <sup>[![Version Badge][npm-version-svg]][package-url]</sup>\n\n[![github actions][actions-image]][actions-url]\n[![coverage][codecov-image]][codecov-url]\n[![License][license-image]][license-url]\n[![Downloads][downloads-image]][downloads-url]\n\n[![npm badge][npm-badge-png]][package-url]\n\nConcatenative mapdashery.\n\n## example\n\n``` js\nvar concatMap = require('concat-map');\nvar xs = [ 1, 2, 3, 4, 5, 6 ];\nvar ys = concatMap(xs, function (x) {\n    return x % 2 ? [ x - 0.1, x, x + 0.1 ] : [];\n});\nconsole.dir(ys);\n```\n\n\n```js\n[ 0.9, 1, 1.1, 2.9, 3, 3.1, 4.9, 5, 5.1 ]\n```\n\n## methods\n\n```js\nvar concatMap = require('concat-map')\n```\n\nconcatMap(xs, fn)\n-----------------\n\nReturn an array of concatenated elements by calling `fn(x, i)` for each element\n`x` and each index `i` in the array `xs`.\n\nWhen `fn(x, i)` returns an array, its result will be concatenated with the\nresult array. If `fn(x, i)` returns anything else, that value will be pushed\nonto the end of the result array.\n\n## install\n\nWith [npm](http://npmjs.org) do:\n\n```sh\nnpm install concat-map\n```\n\n## license\n\nMIT\n\n## notes\n\nThis module was written while sitting high above the ground in a tree.\n\n[package-url]: https://npmjs.org/package/concat-map\n[npm-version-svg]: https://versionbadg.es/ljharb/concat-map.svg\n[deps-svg]: https://david-dm.org/ljharb/concat-map.svg\n[deps-url]: https://david-dm.org/ljharb/concat-map\n[dev-deps-svg]: https://david-dm.org/ljharb/concat-map/dev-status.svg\n[dev-deps-url]: https://david-dm.org/ljharb/concat-map#info=devDependencies\n[npm-badge-png]: https://nodei.co/npm/concat-map.png?downloads=true&stars=true\n[license-image]: https://img.shields.io/npm/l/concat-map.svg\n[license-url]: LICENSE\n[downloads-image]: https://img.shields.io/npm/dm/concat-map.svg\n[downloads-url]: https://npm-stat.com/charts.html?package=concat-map\n[codecov-image]: https://codecov.io/gh/ljharb/concat-map/branch/main/graphs/badge.svg\n[codecov-url]: https://app.codecov.io/gh/ljharb/concat-map/\n[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/concat-map\n[actions-url]: https://github.com/ljharb/concat-map/actions",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{b7/30/62e32b2625e8c8404685db1bb7a4d417f0cf0b7d62af0ff04dd9a4b951a6c56ec29d01eb6fa0e8283890cd084333048b2aa6204193973396805768dca9a4 → 72/51/6fe23b544db879083b5914cca0199a4bab84376c8fd70101201c4539dbefb308bdbbde13cdbef3b888b5ecb3d056f948daad3305cba2dead555179d11544}

@@ -483,7 +483,7 @@
   "dist-tags": {
     "latest": "1.0.5"
   },
-  "_rev": "75-f5838f2293b4286e",
+  "_rev": "76-884466643c514f6f",
   "_id": "format-util",
   "readme": "Table of Contents\n=================\n\n* [Format Util](#format-util)\n  * [Install](#install)\n  * [Usage](#usage)\n  * [Developer](#developer)\n    * [Test](#test)\n    * [Spec](#spec)\n    * [Cover](#cover)\n    * [Browserify](#browserify)\n    * [Lint](#lint)\n    * [Clean](#clean)\n    * [Docs](#docs)\n    * [Readme](#readme)\n  * [License](#license)\n\nFormat Util\n===========\n\n[<img src=\"https://travis-ci.org/tmpfs/format-util.svg\" alt=\"Build Status\">](https://travis-ci.org/tmpfs/format-util)\n[<img src=\"http://img.shields.io/npm/v/format-util.svg\" alt=\"npm version\">](https://npmjs.org/package/format-util)\n[<img src=\"https://coveralls.io/repos/tmpfs/format-util/badge.svg?branch=master&service=github&v=1\" alt=\"Coverage Status\">](https://coveralls.io/github/tmpfs/format-util?branch=master).\n\nLightweight format utility for the browser, based on `util.format()`.\n\n## Install\n\n```\nnpm i format-util\n```\n\n## Usage\n\n```javascript\nvar format = require('format-util')\n  , msg = format('%s', 'foo');\n```\n\n## Developer\n\n### Test\n\nRun the test specifications:\n\n```\nnpm test\n```\n\n### Spec\n\nCompile test specifications for the browser (open `test/index.html`):\n\n```\nnpm run spec\n```\n\n### Cover\n\nGenerate code coverage:\n\n```\nnpm run cover\n```\n\n### Browserify\n\nCreate a standalone browserify build:\n\n```\nnpm run browserify\n```\n\n### Lint\n\nLint the source tree with [jshint](http://jshint.com) and [jscs](http://jscs.info):\n\n```\nnpm run lint\n```\n\n### Clean\n\nRemove generated files:\n\n```\nnpm run clean\n```\n\n### Docs\n\nTo generate all documentation:\n\n```\nnpm run docs\n```\n\n### Readme\n\nGenerate the project readme file [mdp](https://github.com/tmpfs/mdp):\n\n```\nnpm run readme\n```\n\n## License\n\nEverything is [MIT](http://en.wikipedia.org/wiki/MIT_License). Read the [license](https://github.com/tmpfs/format-util/blob/master/LICENSE) if you feel inclined.\n\nGenerated by [mdp(1)](https://github.com/tmpfs/mdp).\n\n[node]: http://nodejs.org\n[npm]: http://www.npmjs.org\n[mdp]: https://github.com/tmpfs/mdp\n[zephyr]: https://github.com/tmpfs/zephyr\n[jshint]: http://jshint.com\n[jscs]: http://jscs.info",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0e/f7/fd8912cd2bc1bfad5920a24aee8dfd74f58025173b7f7a96690c4ab7d6b807e62b3b5cf03f73da3254af21714e99fc684239ff41248f3f1f1d2d669e1e1a → 72/b7/3b0c175c36212a77264c4bf676e43f41f8da9e08d2fe11fe5ea28173c22a0810cdc1a53c4c0f791d122ab4f22d068363edf6922287e26063566b1a8b231c}

@@ -1103,7 +1103,7 @@
   "dist-tags": {
     "latest": "5.2.0"
   },
-  "_rev": "88-61b45564c0f4bb4b",
+  "_rev": "89-b2dd09ccc3f42cde",
   "_id": "@aws-crypto/util",
   "readme": "# @aws-crypto/util\n\nHelper functions\n\n## Usage\n\n```\nimport { convertToBuffer } from '@aws-crypto/util';\n\nconst data = \"asdf\";\nconst utf8EncodedUint8Array = convertToBuffer(data);\n```\n\n## Test\n\n`npm test`",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{14/47/db51f7d0a622c97d472f8a459113c1dee4ccd271b7068d1095f572edc98380244627f6902e6fca27746b62a0832af0e8fe5de9c35eca77b497b5cfc29b82 → 73/7b/b610829f7a624f00234c9c34051c701947d688d264c06e52ccb7615ad2464fae4a6ff7e08af8ae8f2ccfa570e23a1f45a3de23af7659bdf8cfad689cfee9}

@@ -1470,7 +1470,7 @@
   "dist-tags": {
     "latest": "1.5.1"
   },
-  "_rev": "1928-e9a017f9bf5542ae",
+  "_rev": "1929-9ffccf48f253892c",
   "_id": "base64-js",
   "readme": "base64-js\n=========\n\n`base64-js` does basic base64 encoding/decoding in pure JS.\n\n[![build status](https://secure.travis-ci.org/beatgammit/base64-js.png)](http://travis-ci.org/beatgammit/base64-js)\n\nMany browsers already have base64 encoding/decoding functionality, but it is for text data, not all-purpose binary data.\n\nSometimes encoding/decoding binary data in the browser is useful, and that is what this module does.\n\n## install\n\nWith [npm](https://npmjs.org) do:\n\n`npm install base64-js` and `var base64js = require('base64-js')`\n\nFor use in web browsers do:\n\n`<script src=\"base64js.min.js\"></script>`\n\n[Get supported base64-js with the Tidelift Subscription](https://tidelift.com/subscription/pkg/npm-base64-js?utm_source=npm-base64-js&utm_medium=referral&utm_campaign=readme)\n\n## methods\n\n`base64js` has three exposed functions, `byteLength`, `toByteArray` and `fromByteArray`, which both take a single argument.\n\n* `byteLength` - Takes a base64 string and returns length of byte array\n* `toByteArray` - Takes a base64 string and returns a byte array\n* `fromByteArray` - Takes a byte array and returns a base64 string\n\n## license\n\nMIT",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{cc/db/a273217af3518dd33dd294b1feb33dde180f58ec56879757b97d08442bb1966fbfcb290fe2e82b1fb07e5c89ee8a216d58550c819f946210309e67b694c6 → 73/a5/11eb5b5f2c0f4568627f565e18dc8e8e8e72cbc7dfb0fd36cb25b7dcd58d7889374ee667e546b00c4b4792737ed2600d752ed6e4027d171b876f0e78567e}

@@ -20011,7 +20011,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "95-9a776439c0a49ecb",
+  "_rev": "96-4ca4ba4a8e4fb774",
   "_id": "@aws-sdk/credential-provider-env",
   "readme": "# @aws-sdk/credential-provider-env\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/credential-provider-env/latest.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-env)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/credential-provider-env.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-env)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly. Please use [@aws-sdk/credential-providers](https://www.npmjs.com/package/@aws-sdk/credential-providers)\ninstead.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{97/1c/5041e278cd8d88ebad1546f51c244be12cc787f2a7db2a539b295f7340ceff4ee5cbf335bac19c626189a8a739f65b4aaaef05b113bd50b1799cf9615cdb → 74/5b/b925fd19c338b3be7319df96388fa97a1494db04e6536430906be507d46bad640f7664945158d5c13f04854bdd07301dc2943e6338f2c1b291844481a610}

@@ -2061,7 +2061,7 @@
     "latest": "9.0.0",
     "next": "2.1.0-candidate"
   },
-  "_rev": "1882-99dbb38c8eb173c6",
+  "_rev": "1884-1fc3ceb0ebc0a200",
   "_id": "wrap-ansi",
   "readme": "# wrap-ansi\n\n> Wordwrap a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)\n\n## Install\n\n```sh\nnpm install wrap-ansi\n```\n\n## Usage\n\n```js\nimport chalk from 'chalk';\nimport wrapAnsi from 'wrap-ansi';\n\nconst input = 'The quick brown ' + chalk.red('fox jumped over ') +\n\t'the lazy ' + chalk.green('dog and then ran away with the unicorn.');\n\nconsole.log(wrapAnsi(input, 20));\n```\n\n<img width=\"331\" src=\"screenshot.png\">\n\n## API\n\n### wrapAnsi(string, columns, options?)\n\nWrap words to the specified column width.\n\n#### string\n\nType: `string`\n\nA string with ANSI escape codes, like one styled by [`chalk`](https://github.com/chalk/chalk).\n\nNewline characters will be normalized to `\\n`.\n\n#### columns\n\nType: `number`\n\nThe number of columns to wrap the text to.\n\n#### options\n\nType: `object`\n\n##### hard\n\nType: `boolean`\\\nDefault: `false`\n\nBy default the wrap is soft, meaning long words may extend past the column width. Setting this to `true` will make it hard wrap at the column width.\n\n##### wordWrap\n\nType: `boolean`\\\nDefault: `true`\n\nBy default, an attempt is made to split words at spaces, ensuring that they don't extend past the configured columns. If wordWrap is `false`, each column will instead be completely filled splitting words as necessary.\n\n##### trim\n\nType: `boolean`\\\nDefault: `true`\n\nWhitespace on all lines is removed by default. Set this option to `false` if you don't want to trim.\n\n## Related\n\n- [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes\n- [cli-truncate](https://github.com/sindresorhus/cli-truncate) - Truncate a string to a specific width in the terminal\n- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right\n- [jsesc](https://github.com/mathiasbynens/jsesc) - Generate ASCII-only output from Unicode strings. Useful for creating test fixtures.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{e4/19/dbee1562d9e7d7f9fe068545c5a1d6f3f77988b94db9355401b093ded1f5b2946ef76449818d8f189106d375ab61266585ee6e14c054dc2665bee2015d86 → 74/79/33d19dfcebc51bff531516f0942ff952a39e9b64f8a7c6dccad96f70efba17e977a3eda3965036cd5c35d7385a350499267fbafc772fd98b7db6b980935f}

@@ -14049,7 +14049,7 @@
     "v7.4-backport": "7.4.5",
     "legacy-v10": "10.4.3"
   },
-  "_rev": "1546-f4eac918e4302b05",
+  "_rev": "1547-3349c6a50387680e",
   "_id": "lru-cache",
   "readme": "# lru-cache\n\nA cache object that deletes the least-recently-used items.\n\nSpecify a max number of the most recently used items that you\nwant to keep, and this cache will keep that many of the most\nrecently accessed items.\n\nThis is not primarily a TTL cache, and does not make strong TTL\nguarantees. There is no preemptive pruning of expired items by\ndefault, but you _may_ set a TTL on the cache or on a single\n`set`. If you do so, it will treat expired items as missing, and\ndelete them when fetched. If you are more interested in TTL\ncaching than LRU caching, check out\n[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).\n\nAs of version 7, this is one of the most performant LRU\nimplementations available in JavaScript, and supports a wide\ndiversity of use cases. However, note that using some of the\nfeatures will necessarily impact performance, by causing the\ncache to have to do more work. See the \"Performance\" section\nbelow.\n\n## Installation\n\n```bash\nnpm install lru-cache --save\n```\n\n## Usage\n\n```js\n// hybrid module, either works\nimport { LRUCache } from 'lru-cache'\n// or:\nconst { LRUCache } = require('lru-cache')\n// or in minified form for web browsers:\nimport { LRUCache } from 'http://unpkg.com/lru-cache@9/dist/mjs/index.min.mjs'\n\n// At least one of 'max', 'ttl', or 'maxSize' is required, to prevent\n// unsafe unbounded storage.\n//\n// In most cases, it's best to specify a max for performance, so all\n// the required memory allocation is done up-front.\n//\n// All the other options are optional, see the sections below for\n// documentation on what each one does.  Most of them can be\n// overridden for specific items in get()/set()\nconst options = {\n  max: 500,\n\n  // for use with tracking overall storage size\n  maxSize: 5000,\n  sizeCalculation: (value, key) => {\n    return 1\n  },\n\n  // for use when you need to clean up something when objects\n  // are evicted from the cache\n  dispose: (value, key, reason) => {\n    freeFromMemoryOrWhatever(value)\n  },\n\n  // for use when you need to know that an item is being inserted\n  // note that this does NOT allow you to prevent the insertion,\n  // it just allows you to know about it.\n  onInsert: (value, key, reason) => {\n    logInsertionOrWhatever(key, value)\n  },\n\n  // how long to live in ms\n  ttl: 1000 * 60 * 5,\n\n  // return stale items before removing from cache?\n  allowStale: false,\n\n  updateAgeOnGet: false,\n  updateAgeOnHas: false,\n\n  // async method to use for cache.fetch(), for\n  // stale-while-revalidate type of behavior\n  fetchMethod: async (\n    key,\n    staleValue,\n    { options, signal, context }\n  ) => {},\n}\n\nconst cache = new LRUCache(options)\n\ncache.set('key', 'value')\ncache.get('key') // \"value\"\n\n// non-string keys ARE fully supported\n// but note that it must be THE SAME object, not\n// just a JSON-equivalent object.\nvar someObject = { a: 1 }\ncache.set(someObject, 'a value')\n// Object keys are not toString()-ed\ncache.set('[object Object]', 'a different value')\nassert.equal(cache.get(someObject), 'a value')\n// A similar object with same keys/values won't work,\n// because it's a different object identity\nassert.equal(cache.get({ a: 1 }), undefined)\n\ncache.clear() // empty the cache\n```\n\nIf you put more stuff in the cache, then less recently used items\nwill fall out. That's what an LRU cache is.\n\nFor full description of the API and all options, please see [the\nLRUCache typedocs](https://isaacs.github.io/node-lru-cache/)\n\n## Storage Bounds Safety\n\nThis implementation aims to be as flexible as possible, within\nthe limits of safe memory consumption and optimal performance.\n\nAt initial object creation, storage is allocated for `max` items.\nIf `max` is set to zero, then some performance is lost, and item\ncount is unbounded. Either `maxSize` or `ttl` _must_ be set if\n`max` is not specified.\n\nIf `maxSize` is set, then this creates a safe limit on the\nmaximum storage consumed, but without the performance benefits of\npre-allocation. When `maxSize` is set, every item _must_ provide\na size, either via the `sizeCalculation` method provided to the\nconstructor, or via a `size` or `sizeCalculation` option provided\nto `cache.set()`. The size of every item _must_ be a positive\ninteger.\n\nIf neither `max` nor `maxSize` are set, then `ttl` tracking must\nbe enabled. Note that, even when tracking item `ttl`, items are\n_not_ preemptively deleted when they become stale, unless\n`ttlAutopurge` is enabled. Instead, they are only purged the\nnext time the key is requested. Thus, if `ttlAutopurge`, `max`,\nand `maxSize` are all not set, then the cache will potentially\ngrow unbounded.\n\nIn this case, a warning is printed to standard error. Future\nversions may require the use of `ttlAutopurge` if `max` and\n`maxSize` are not specified.\n\nIf you truly wish to use a cache that is bound _only_ by TTL\nexpiration, consider using a `Map` object, and calling\n`setTimeout` to delete entries when they expire. It will perform\nmuch better than an LRU cache.\n\nHere is an implementation you may use, under the same\n[license](./LICENSE) as this package:\n\n```js\n// a storage-unbounded ttl cache that is not an lru-cache\nconst cache = {\n  data: new Map(),\n  timers: new Map(),\n  set: (k, v, ttl) => {\n    if (cache.timers.has(k)) {\n      clearTimeout(cache.timers.get(k))\n    }\n    cache.timers.set(\n      k,\n      setTimeout(() => cache.delete(k), ttl)\n    )\n    cache.data.set(k, v)\n  },\n  get: k => cache.data.get(k),\n  has: k => cache.data.has(k),\n  delete: k => {\n    if (cache.timers.has(k)) {\n      clearTimeout(cache.timers.get(k))\n    }\n    cache.timers.delete(k)\n    return cache.data.delete(k)\n  },\n  clear: () => {\n    cache.data.clear()\n    for (const v of cache.timers.values()) {\n      clearTimeout(v)\n    }\n    cache.timers.clear()\n  },\n}\n```\n\nIf that isn't to your liking, check out\n[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).\n\n## Storing Undefined Values\n\nThis cache never stores undefined values, as `undefined` is used\ninternally in a few places to indicate that a key is not in the\ncache.\n\nYou may call `cache.set(key, undefined)`, but this is just\nan alias for `cache.delete(key)`. Note that this has the effect\nthat `cache.has(key)` will return _false_ after setting it to\nundefined.\n\n```js\ncache.set(myKey, undefined)\ncache.has(myKey) // false!\n```\n\nIf you need to track `undefined` values, and still note that the\nkey is in the cache, an easy workaround is to use a sigil object\nof your own.\n\n```js\nimport { LRUCache } from 'lru-cache'\nconst undefinedValue = Symbol('undefined')\nconst cache = new LRUCache(...)\nconst mySet = (key, value) =>\n  cache.set(key, value === undefined ? undefinedValue : value)\nconst myGet = (key, value) => {\n  const v = cache.get(key)\n  return v === undefinedValue ? undefined : v\n}\n```\n\n## Performance\n\nAs of January 2022, version 7 of this library is one of the most\nperformant LRU cache implementations in JavaScript.\n\nBenchmarks can be extremely difficult to get right. In\nparticular, the performance of set/get/delete operations on\nobjects will vary _wildly_ depending on the type of key used. V8\nis highly optimized for objects with keys that are short strings,\nespecially integer numeric strings. Thus any benchmark which\ntests _solely_ using numbers as keys will tend to find that an\nobject-based approach performs the best.\n\nNote that coercing _anything_ to strings to use as object keys is\nunsafe, unless you can be 100% certain that no other type of\nvalue will be used. For example:\n\n```js\nconst myCache = {}\nconst set = (k, v) => (myCache[k] = v)\nconst get = k => myCache[k]\n\nset({}, 'please hang onto this for me')\nset('[object Object]', 'oopsie')\n```\n\nAlso beware of \"Just So\" stories regarding performance. Garbage\ncollection of large (especially: deep) object graphs can be\nincredibly costly, with several \"tipping points\" where it\nincreases exponentially. As a result, putting that off until\nlater can make it much worse, and less predictable. If a library\nperforms well, but only in a scenario where the object graph is\nkept shallow, then that won't help you if you are using large\nobjects as keys.\n\nIn general, when attempting to use a library to improve\nperformance (such as a cache like this one), it's best to choose\nan option that will perform well in the sorts of scenarios where\nyou'll actually use it.\n\nThis library is optimized for repeated gets and minimizing\neviction time, since that is the expected need of a LRU. Set\noperations are somewhat slower on average than a few other\noptions, in part because of that optimization. It is assumed\nthat you'll be caching some costly operation, ideally as rarely\nas possible, so optimizing set over get would be unwise.\n\nIf performance matters to you:\n\n1. If it's at all possible to use small integer values as keys,\n   and you can guarantee that no other types of values will be\n   used as keys, then do that, and use a cache such as\n   [lru-fast](https://npmjs.com/package/lru-fast), or\n   [mnemonist's\n   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache)\n   which uses an Object as its data store.\n\n2. Failing that, if at all possible, use short non-numeric\n   strings (ie, less than 256 characters) as your keys, and use\n   [mnemonist's\n   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache).\n\n3. If the types of your keys will be anything else, especially\n   long strings, strings that look like floats, objects, or some\n   mix of types, or if you aren't sure, then this library will\n   work well for you.\n\n   If you do not need the features that this library provides\n   (like asynchronous fetching, a variety of TTL staleness\n   options, and so on), then [mnemonist's\n   LRUMap](https://yomguithereal.github.io/mnemonist/lru-map) is\n   a very good option, and just slightly faster than this module\n   (since it does considerably less).\n\n4. Do not use a `dispose` function, size tracking, or especially\n   ttl behavior, unless absolutely needed. These features are\n   convenient, and necessary in some use cases, and every attempt\n   has been made to make the performance impact minimal, but it\n   isn't nothing.\n\n## Breaking Changes in Version 7\n\nThis library changed to a different algorithm and internal data\nstructure in version 7, yielding significantly better\nperformance, albeit with some subtle changes as a result.\n\nIf you were relying on the internals of LRUCache in version 6 or\nbefore, it probably will not work in version 7 and above.\n\n## Breaking Changes in Version 8\n\n- The `fetchContext` option was renamed to `context`, and may no\n  longer be set on the cache instance itself.\n- Rewritten in TypeScript, so pretty much all the types moved\n  around a lot.\n- The AbortController/AbortSignal polyfill was removed. For this\n  reason, **Node version 16.14.0 or higher is now required**.\n- Internal properties were moved to actual private class\n  properties.\n- Keys and values must not be `null` or `undefined`.\n- Minified export available at `'lru-cache/min'`, for both CJS\n  and MJS builds.\n\n## Breaking Changes in Version 9\n\n- Named export only, no default export.\n- AbortController polyfill returned, albeit with a warning when\n  used.\n\n## Breaking Changes in Version 10\n\n- `cache.fetch()` return type is now `Promise<V | undefined>`\n  instead of `Promise<V | void>`. This is an irrelevant change\n  practically speaking, but can require changes for TypeScript\n  users.\n\nFor more info, see the [change log](CHANGELOG.md).",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{35/01/2e87508846f5be516c3287da34924dc665701038f5f8c70f7a1f37d6f2a81d4b5249a1c04667e84549ac12a415bae7fbac95aa9810077bbfcf37d9751096 → 79/5c/d22b919d393c3459ad5b1b7c4e259a28c5275e2e24cd3f3cdddb9ffa234193c2f828a4813941522134ccb98d593a6ba53059964e5f952c9336ddf45014a4}

@@ -137,7 +137,7 @@
   "dist-tags": {
     "latest": "8.0.2"
   },
-  "_rev": "131-9dbdc505a745bd07",
+  "_rev": "132-31d320c91cf2db67",
   "_id": "@isaacs/cliui",
   "readme": "# @isaacs/cliui\n\nTemporary fork of [cliui](http://npm.im/cliui).\n\n![ci](https://github.com/yargs/cliui/workflows/ci/badge.svg)\n[![NPM version](https://img.shields.io/npm/v/cliui.svg)](https://www.npmjs.com/package/cliui)\n[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)\n![nycrc config on GitHub](https://img.shields.io/nycrc/yargs/cliui)\n\neasily create complex multi-column command-line-interfaces.\n\n## Example\n\n```js\nconst ui = require('cliui')()\n\nui.div('Usage: $0 [command] [options]')\n\nui.div({\n  text: 'Options:',\n  padding: [2, 0, 1, 0]\n})\n\nui.div(\n  {\n    text: \"-f, --file\",\n    width: 20,\n    padding: [0, 4, 0, 4]\n  },\n  {\n    text: \"the file to load.\" +\n      chalk.green(\"(if this description is long it wraps).\")\n    ,\n    width: 20\n  },\n  {\n    text: chalk.red(\"[required]\"),\n    align: 'right'\n  }\n)\n\nconsole.log(ui.toString())\n```\n\n## Deno/ESM Support\n\nAs of `v7` `cliui` supports [Deno](https://github.com/denoland/deno) and\n[ESM](https://nodejs.org/api/esm.html#esm_ecmascript_modules):\n\n```typescript\nimport cliui from \"https://deno.land/x/cliui/deno.ts\";\n\nconst ui = cliui({})\n\nui.div('Usage: $0 [command] [options]')\n\nui.div({\n  text: 'Options:',\n  padding: [2, 0, 1, 0]\n})\n\nui.div({\n  text: \"-f, --file\",\n  width: 20,\n  padding: [0, 4, 0, 4]\n})\n\nconsole.log(ui.toString())\n```\n\n<img width=\"500\" src=\"screenshot.png\">\n\n## Layout DSL\n\ncliui exposes a simple layout DSL:\n\nIf you create a single `ui.div`, passing a string rather than an\nobject:\n\n* `\\n`: characters will be interpreted as new rows.\n* `\\t`: characters will be interpreted as new columns.\n* `\\s`: characters will be interpreted as padding.\n\n**as an example...**\n\n```js\nvar ui = require('./')({\n  width: 60\n})\n\nui.div(\n  'Usage: node ./bin/foo.js\\n' +\n  '  <regex>\\t  provide a regex\\n' +\n  '  <glob>\\t  provide a glob\\t [required]'\n)\n\nconsole.log(ui.toString())\n```\n\n**will output:**\n\n```shell\nUsage: node ./bin/foo.js\n  <regex>  provide a regex\n  <glob>   provide a glob          [required]\n```\n\n## Methods\n\n```js\ncliui = require('cliui')\n```\n\n### cliui({width: integer})\n\nSpecify the maximum width of the UI being generated.\nIf no width is provided, cliui will try to get the current window's width and use it, and if that doesn't work, width will be set to `80`.\n\n### cliui({wrap: boolean})\n\nEnable or disable the wrapping of text in a column.\n\n### cliui.div(column, column, column)\n\nCreate a row with any number of columns, a column\ncan either be a string, or an object with the following\noptions:\n\n* **text:** some text to place in the column.\n* **width:** the width of a column.\n* **align:** alignment, `right` or `center`.\n* **padding:** `[top, right, bottom, left]`.\n* **border:** should a border be placed around the div?\n\n### cliui.span(column, column, column)\n\nSimilar to `div`, except the next row will be appended without\na new line being created.\n\n### cliui.resetOutput()\n\nResets the UI elements of the current cliui instance, maintaining the values\nset for `width` and `wrap`.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{ed/7a/4cbb90eb0e8d8eab0f9bd99575378a3eca07bafcb529c5c7a6854dc29e1793a30876aa6d52408583b24595e1239e1596f93267ef68c5f0aa68ddcf7c4f32 → 7d/6e/cd3f9079a0ceda13a90cfe1e7da1d104b0f3029e3f0883e67398d3487fd6cea3aa3a17e76624d4a4c3a10d389d45322142827d635cb14cb72bca2f90e1f7}

@@ -1604,7 +1604,7 @@
   "dist-tags": {
     "latest": "6.1.0"
   },
-  "_rev": "1756-065d3fefaf6c1e2a",
+  "_rev": "1758-a6ebf47abb469c04",
   "_id": "ansi-regex",
   "readme": "# ansi-regex\n\n> Regular expression for matching [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code)\n\n## Install\n\n```sh\nnpm install ansi-regex\n```\n\n## Usage\n\n```js\nimport ansiRegex from 'ansi-regex';\n\nansiRegex().test('\\u001B[4mcake\\u001B[0m');\n//=> true\n\nansiRegex().test('cake');\n//=> false\n\n'\\u001B[4mcake\\u001B[0m'.match(ansiRegex());\n//=> ['\\u001B[4m', '\\u001B[0m']\n\n'\\u001B[4mcake\\u001B[0m'.match(ansiRegex({onlyFirst: true}));\n//=> ['\\u001B[4m']\n\n'\\u001B]8;;https://github.com\\u0007click\\u001B]8;;\\u0007'.match(ansiRegex());\n//=> ['\\u001B]8;;https://github.com\\u0007', '\\u001B]8;;\\u0007']\n```\n\n## API\n\n### ansiRegex(options?)\n\nReturns a regex for matching ANSI escape codes.\n\n#### options\n\nType: `object`\n\n##### onlyFirst\n\nType: `boolean`\\\nDefault: `false` *(Matches any ANSI escape codes in a string)*\n\nMatch only the first ANSI escape.\n\n## FAQ\n\n### Why do you test for codes not in the ECMA 48 standard?\n\nSome of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. We test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them.\n\nOn the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of \"interrupts\" that can mean different things on certain brands of processors, most of which have been phased out.\n\n## Maintainers\n\n- [Sindre Sorhus](https://github.com/sindresorhus)\n- [Josh Junon](https://github.com/qix-)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{5d/ff/1c70faea7e2115ac9f3228754b05dc0547f829e882e5224834e864c1e47f68f5ca4fd6becf47d9418fbe711dee20efa24503f7ca61b3db5165f407fb545a → 7d/fc/55402f4f4157b9af34ebe2d5634b00603ff15c15369c52045bb02eee3888a98d9eb2b3c2344b642d3a0c8720bf42b0533ac43de8003006b8af980a5dda21}

@@ -12514,7 +12514,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "88-4108be7d16640112",
+  "_rev": "89-67c96b4e377d8622",
   "_id": "@aws-sdk/middleware-content-length",
   "readme": "# @aws-sdk/middleware-content-length\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-content-length/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-content-length)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-content-length.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-content-length)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{8f/d1/fee5eafcb6ca558c154c62139826d7a02da7f448b984140828361978bbdbd7e2cf171d211c957a395ba788d48aefed422dec2e4fbe5fc25dfdd33440e38c → 7d/fe/c6748c738c06c36ac4a71d40657037d85d9c017e22903f3cb0695b930b29d81cfd552e6e808b4bbade6eeaa64e4e5a9966616ded3e1e844561b17f889b98}

@@ -5910,7 +5910,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "115-82343ebb7906aa10",
+  "_rev": "118-6fe96652d0f71bd2",
   "_id": "@aws-sdk/util-locate-window",
   "readme": "# @aws-sdk/util-locate-window\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-locate-window/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-locate-window)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-locate-window.svg)](https://www.npmjs.com/package/@aws-sdk/util-locate-window)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{03/f6/137a86ef35bfd249f8796617465de2875f7ee4c53b31bcc04feff5aa25059351b973a69bcfc2c36dccbf59b079c6d30ad1b45f41e4520056de7472a1e1f4 → 81/f0/ce56964d14c461f25f8f35cb37e673447e57d45d9015833a9dcba0faec58edcb70ee0dbb22b73cf9719d1c45824e859ab9e38eafb81a864f3fac7da67f1f}

@@ -17030,7 +17030,7 @@
   "dist-tags": {
     "latest": "3.775.0"
   },
-  "_rev": "82-73f09b089b9d4881",
+  "_rev": "83-ccb403c32b1727be",
   "_id": "@aws-sdk/middleware-flexible-checksums",
   "readme": "# @aws-sdk/middleware-flexible-checksums\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-flexible-checksums/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-flexible-checksums.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)\n\nThis package provides AWS SDK for JavaScript middleware that applies a checksum\nof the request body as a header.",
   "_attachments": {}