mrs-toolbox-cli 6.0.2 → 6.0.3

package/mrs-toolbox-cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../cli/src/commonMain/kotlin/mrsc.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/src/kotlin/collections/Collections.kt","../../../../../../../../../../../Users/runner/work/clikt/clikt/clikt/src/commonMain/kotlin/com/github/ajalt/clikt/parsers/CommandLineParser.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/js/src/kotlin/AutoCloseableJs.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/src/kotlin/collections/MutableCollections.kt","../../../../../cli/src/jsMain/kotlin/mrsc.js.kt"],"sourcesContent":[null,null,null,null,null,null],"names":["<init>","name","invoke","$this$flow","$completion","doResume","Mrsc$run$slambda","Mrsc$run$slambda$lambda","run","WorkingDir$run$slambda","WorkingDir$run$slambda$lambda","help","context","<get-workingDir>","Test$run$slambda","Test$run$slambda$lambda","<get-config>","Prepare$run$slambda","Prepare$run$slambda$lambda","it","Export$run$slambda$slambda","Export$run$slambda$slambda$lambda","emit","value","equals","hashCode","Export$run$slambda","Export$run$slambda$lambda","<get-version>","Upload$run$slambda$slambda","Upload$run$slambda$slambda$lambda","Upload$run$slambda","Upload$run$slambda$lambda","<get-configFileName>","Version$run$slambda","Version$run$slambda$lambda","Migrate$run$slambda","Migrate$run$slambda$lambda","parse","<this>","argv","flows","result","exception","invocation","e","main","commonMain","command","resultFlow","$flows","parse$slambda","parse$slambda$lambda","$command","commonMain$slambda","commonMain$slambda$lambda","workingDir$factory","get","receiver","config$factory","version$factory","configFileName$factory","args"],"mappings":"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"}
+{"version":3,"sources":["../../../../../cli/src/commonMain/kotlin/mrsc.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/src/kotlin/collections/Collections.kt","../../../../../../../../../../../Users/runner/work/clikt/clikt/clikt/src/commonMain/kotlin/com/github/ajalt/clikt/parsers/CommandLineParser.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/js/src/kotlin/AutoCloseableJs.kt","../../../../../cli/build/compileSync/js/main/productionLibrary/kotlin/src/kotlin/collections/MutableCollections.kt","../../../../../cli/src/jsMain/kotlin/mrsc.js.kt"],"sourcesContent":[null,null,null,null,null,null],"names":["<init>","name","invoke","$this$flow","$completion","doResume","Mrsc$run$slambda","Mrsc$run$slambda$lambda","run","WorkingDir$run$slambda","WorkingDir$run$slambda$lambda","help","context","<get-workingDir>","it","Test$run$slambda$slambda","Test$run$slambda$slambda$lambda","emit","value","equals","hashCode","Test$run$slambda","Test$run$slambda$lambda","<get-config>","Prepare$run$slambda","Prepare$run$slambda$lambda","Export$run$slambda$slambda","Export$run$slambda$slambda$lambda","Export$run$slambda","Export$run$slambda$lambda","<get-version>","Upload$run$slambda$slambda","Upload$run$slambda$slambda$lambda","Upload$run$slambda","Upload$run$slambda$lambda","<get-configFileName>","Version$run$slambda","Version$run$slambda$lambda","Migrate$run$slambda","Migrate$run$slambda$lambda","parse","<this>","argv","flows","result","exception","invocation","e","main","commonMain","command","resultFlow","$flows","parse$slambda","parse$slambda$lambda","$command","commonMain$slambda","commonMain$slambda$lambda","workingDir$factory","get","receiver","config$factory","version$factory","configFileName$factory","args"],"mappings":"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"}

package/npm-cache/_cacache/content-v2/sha512/{cf/18/e6a916f67307ca554257d273a184d261e6a86996e5a50133212c0cac9b34e4ff276bd1ccaf2425e8cf5834d79c8e97439fa23c169eb317a812111f6687ff → 00/07/005d0f26bad04ada92e9f3048a71b6e97825a9eaf330a7ff3d378bca7a15893af60d7e53f9c867f40723b83cfd64aab1bd64b130070b9259b3c01846bb75}

@@ -5530,7 +5530,7 @@
   "dist-tags": {
     "latest": "14.2.0"
   },
-  "_rev": "1181-58e64589cdc0fc42",
+  "_rev": "1182-58eacbb56ba3ac52",
   "_id": "whatwg-url",
   "readme": "# whatwg-url\n\nwhatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spec.whatwg.org/). It can be used standalone, but it also exposes a lot of the internal algorithms that are useful for integrating a URL parser into a project like [jsdom](https://github.com/jsdom/jsdom).\n\n## Specification conformance\n\nwhatwg-url is currently up to date with the URL spec up to commit [6c78200](https://github.com/whatwg/url/commit/6c782003a2d53b1feecd072d1006eb8f1d65fb2d).\n\nFor `file:` URLs, whose [origin is left unspecified](https://url.spec.whatwg.org/#concept-url-origin), whatwg-url chooses to use a new opaque origin (which serializes to `\"null\"`).\n\nwhatwg-url does not yet implement any encoding handling beyond UTF-8. That is, the _encoding override_ parameter does not exist in our API.\n\n## API\n\n### The `URL` and `URLSearchParams` classes\n\nThe main API is provided by the [`URL`](https://url.spec.whatwg.org/#url-class) and [`URLSearchParams`](https://url.spec.whatwg.org/#interface-urlsearchparams) exports, which follows the spec's behavior in all ways (including e.g. `USVString` conversion). Most consumers of this library will want to use these.\n\n### Low-level URL Standard API\n\nThe following methods are exported for use by places like jsdom that need to implement things like [`HTMLHyperlinkElementUtils`](https://html.spec.whatwg.org/#htmlhyperlinkelementutils). They mostly operate on or return an \"internal URL\" or [\"URL record\"](https://url.spec.whatwg.org/#concept-url) type.\n\n- [URL parser](https://url.spec.whatwg.org/#concept-url-parser): `parseURL(input, { baseURL })`\n- [Basic URL parser](https://url.spec.whatwg.org/#concept-basic-url-parser): `basicURLParse(input, { baseURL, url, stateOverride })`\n- [URL serializer](https://url.spec.whatwg.org/#concept-url-serializer): `serializeURL(urlRecord, excludeFragment)`\n- [Host serializer](https://url.spec.whatwg.org/#concept-host-serializer): `serializeHost(hostFromURLRecord)`\n- [URL path serializer](https://url.spec.whatwg.org/#url-path-serializer): `serializePath(urlRecord)`\n- [Serialize an integer](https://url.spec.whatwg.org/#serialize-an-integer): `serializeInteger(number)`\n- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [serializer](https://html.spec.whatwg.org/multipage/origin.html#ascii-serialisation-of-an-origin): `serializeURLOrigin(urlRecord)`\n- [Set the username](https://url.spec.whatwg.org/#set-the-username): `setTheUsername(urlRecord, usernameString)`\n- [Set the password](https://url.spec.whatwg.org/#set-the-password): `setThePassword(urlRecord, passwordString)`\n- [Has an opaque path](https://url.spec.whatwg.org/#url-opaque-path): `hasAnOpaquePath(urlRecord)`\n- [Cannot have a username/password/port](https://url.spec.whatwg.org/#cannot-have-a-username-password-port): `cannotHaveAUsernamePasswordPort(urlRecord)`\n- [Percent decode bytes](https://url.spec.whatwg.org/#percent-decode): `percentDecodeBytes(uint8Array)`\n- [Percent decode a string](https://url.spec.whatwg.org/#string-percent-decode): `percentDecodeString(string)`\n\nThe `stateOverride` parameter is one of the following strings:\n\n- [`\"scheme start\"`](https://url.spec.whatwg.org/#scheme-start-state)\n- [`\"scheme\"`](https://url.spec.whatwg.org/#scheme-state)\n- [`\"no scheme\"`](https://url.spec.whatwg.org/#no-scheme-state)\n- [`\"special relative or authority\"`](https://url.spec.whatwg.org/#special-relative-or-authority-state)\n- [`\"path or authority\"`](https://url.spec.whatwg.org/#path-or-authority-state)\n- [`\"relative\"`](https://url.spec.whatwg.org/#relative-state)\n- [`\"relative slash\"`](https://url.spec.whatwg.org/#relative-slash-state)\n- [`\"special authority slashes\"`](https://url.spec.whatwg.org/#special-authority-slashes-state)\n- [`\"special authority ignore slashes\"`](https://url.spec.whatwg.org/#special-authority-ignore-slashes-state)\n- [`\"authority\"`](https://url.spec.whatwg.org/#authority-state)\n- [`\"host\"`](https://url.spec.whatwg.org/#host-state)\n- [`\"hostname\"`](https://url.spec.whatwg.org/#hostname-state)\n- [`\"port\"`](https://url.spec.whatwg.org/#port-state)\n- [`\"file\"`](https://url.spec.whatwg.org/#file-state)\n- [`\"file slash\"`](https://url.spec.whatwg.org/#file-slash-state)\n- [`\"file host\"`](https://url.spec.whatwg.org/#file-host-state)\n- [`\"path start\"`](https://url.spec.whatwg.org/#path-start-state)\n- [`\"path\"`](https://url.spec.whatwg.org/#path-state)\n- [`\"opaque path\"`](https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state)\n- [`\"query\"`](https://url.spec.whatwg.org/#query-state)\n- [`\"fragment\"`](https://url.spec.whatwg.org/#fragment-state)\n\nThe URL record type has the following API:\n\n- [`scheme`](https://url.spec.whatwg.org/#concept-url-scheme)\n- [`username`](https://url.spec.whatwg.org/#concept-url-username)\n- [`password`](https://url.spec.whatwg.org/#concept-url-password)\n- [`host`](https://url.spec.whatwg.org/#concept-url-host)\n- [`port`](https://url.spec.whatwg.org/#concept-url-port)\n- [`path`](https://url.spec.whatwg.org/#concept-url-path) (as an array of strings, or a string)\n- [`query`](https://url.spec.whatwg.org/#concept-url-query)\n- [`fragment`](https://url.spec.whatwg.org/#concept-url-fragment)\n\nThese properties should be treated with care, as in general changing them will cause the URL record to be in an inconsistent state until the appropriate invocation of `basicURLParse` is used to fix it up. You can see examples of this in the URL Standard, where there are many step sequences like \"4. Set context object’s url’s fragment to the empty string. 5. Basic URL parse _input_ with context object’s url as _url_ and fragment state as _state override_.\" In between those two steps, a URL record is in an unusable state.\n\nThe return value of \"failure\" in the spec is represented by `null`. That is, functions like `parseURL` and `basicURLParse` can return _either_ a URL record _or_ `null`.\n\n### `whatwg-url/webidl2js-wrapper` module\n\nThis module exports the `URL` and `URLSearchParams` [interface wrappers API](https://github.com/jsdom/webidl2js#for-interfaces) generated by [webidl2js](https://github.com/jsdom/webidl2js).\n\n## Development instructions\n\nFirst, install [Node.js](https://nodejs.org/). Then, fetch the dependencies of whatwg-url, by running from this directory:\n\n    npm install\n\nTo run tests:\n\n    npm test\n\nTo generate a coverage report:\n\n    npm run coverage\n\nTo build and run the live viewer:\n\n    npm run prepare\n    npm run build-live-viewer\n\nServe the contents of the `live-viewer` directory using any web server.\n\n## Supporting whatwg-url\n\nThe jsdom project (including whatwg-url) is a community-driven project maintained by a team of [volunteers](https://github.com/orgs/jsdom/people). You could support us by:\n\n- [Getting professional support for whatwg-url](https://tidelift.com/subscription/pkg/npm-whatwg-url?utm_source=npm-whatwg-url&utm_medium=referral&utm_campaign=readme) as part of a Tidelift subscription. Tidelift helps making open source sustainable for us while giving teams assurances for maintenance, licensing, and security.\n- Contributing directly to the project.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{72/e4/fb28bddf64b68f2a89a83c785589b5d67472e2e10bdf1bc6195ce746833419251b650facd6e21ee5939bd7eb9ae4cf5ad4d606bb06e4d169d37faaf8fef9 → 01/bc/56d935b52893312664922a02d36d75d0f3048bdcda058d6ee762bee5c3a7a3ecc200de7959c3e7dddc7454dff2e762bd0a9ed39afe8319f4ca7fba56171d}

@@ -5536,7 +5536,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "85-dd7855a3bc14428f",
+  "_rev": "86-2580e2071f82b43d",
   "_id": "@aws-sdk/util-buffer-from",
   "readme": "# @aws-sdk/util-buffer-from\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-buffer-from/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-buffer-from)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-buffer-from.svg)](https://www.npmjs.com/package/@aws-sdk/util-buffer-from)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{a2/cd/09073e35fdd6712a917dd8c5643e6ccf9412896966133be5d7ff77ef58481265ec454ff34af9bbcd4ddac8ef8e43d0ef23104b48f0096a236789b653e82d → 04/0d/362eda78158af66d68b00e836291d9c61ba9f94c204bb22423be7f820b271df65f5722a3d09ae75a32887c49a3419fe41a90509d966cf6fc5ae79e5ac463}

@@ -1251,7 +1251,7 @@
   "dist-tags": {
     "latest": "1.2.1"
   },
-  "_rev": "1225-3631dae7498b6cff",
+  "_rev": "1226-90dcc5cd2944f5b9",
   "_id": "ieee754",
   "readme": "# ieee754 [![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/ieee754/master.svg\n[travis-url]: https://travis-ci.org/feross/ieee754\n[npm-image]: https://img.shields.io/npm/v/ieee754.svg\n[npm-url]: https://npmjs.org/package/ieee754\n[downloads-image]: https://img.shields.io/npm/dm/ieee754.svg\n[downloads-url]: https://npmjs.org/package/ieee754\n[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg\n[standard-url]: https://standardjs.com\n\n[![saucelabs][saucelabs-image]][saucelabs-url]\n\n[saucelabs-image]: https://saucelabs.com/browser-matrix/ieee754.svg\n[saucelabs-url]: https://saucelabs.com/u/ieee754\n\n### Read/write IEEE754 floating point numbers from/to a Buffer or array-like object.\n\n## install\n\n```\nnpm install ieee754\n```\n\n## methods\n\n`var ieee754 = require('ieee754')`\n\nThe `ieee754` object has the following functions:\n\n```\nieee754.read = function (buffer, offset, isLE, mLen, nBytes)\nieee754.write = function (buffer, value, offset, isLE, mLen, nBytes)\n```\n\nThe arguments mean the following:\n\n- buffer = the buffer\n- offset = offset into the buffer\n- value = value to set (only for `write`)\n- isLe = is little endian?\n- mLen = mantissa length\n- nBytes = number of bytes\n\n## what is ieee754?\n\nThe IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point computation. [Read more](http://en.wikipedia.org/wiki/IEEE_floating_point).\n\n## license\n\nBSD 3 Clause. Copyright (c) 2008, Fair Oaks Labs, Inc.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{11/00/9e9cc27e66fd633a54d1abdff532f992cf42658947e4615ead0d3056d3200a608b5778e3e22cb5b447e6ba719689a1a42719c3e2a2f9f48e55907fdfd737 → 04/37/4ca03c2ee59574bda6834b48d8a3fe1fb963a8452c688fb57ab828530609d18b3b26217d44363d580d83c10981ceb205a7529150eab946c31be8bffc911c}

@@ -1604,7 +1604,7 @@
   "dist-tags": {
     "latest": "6.1.0"
   },
-  "_rev": "1755-9f0b4a570089f310",
+  "_rev": "1757-9ca8df773b7b02d0",
   "_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/{cd/78/01ea8371324c3e54856f5cebdd28ffd89169cd525ddd626c3f39806336eb49b5ba1a49c5b8b0a177727e7dcb64228329475c0b1aeee43758961315903dc3 → 0b/3e/9733ed053c5d4f840aaf8128405482e4938d6476a22ddf890233be64cb521223e667df80c59357eb68ee1f4ab5491705594bce03b5d9f8eabe114f88cade}

@@ -1961,7 +1961,7 @@
     "latest": "4.1.0",
     "next": "3.0.1"
   },
-  "_rev": "1222-9f992fdef514fa80",
+  "_rev": "1223-9709d2b3174d7052",
   "_id": "signal-exit",
   "readme": "# signal-exit\n\nWhen you want to fire an event no matter how a process exits:\n\n- reaching the end of execution.\n- explicitly having `process.exit(code)` called.\n- having `process.kill(pid, sig)` called.\n- receiving a fatal signal from outside the process\n\nUse `signal-exit`.\n\n```js\n// Hybrid module, either works\nimport { onExit } from 'signal-exit'\n// or:\n// const { onExit } = require('signal-exit')\n\nonExit((code, signal) => {\n  console.log('process exited!', code, signal)\n})\n```\n\n## API\n\n`remove = onExit((code, signal) => {}, options)`\n\nThe return value of the function is a function that will remove\nthe handler.\n\nNote that the function _only_ fires for signals if the signal\nwould cause the process to exit. That is, there are no other\nlisteners, and it is a fatal signal.\n\nIf the global `process` object is not suitable for this purpose\n(ie, it's unset, or doesn't have an `emit` method, etc.) then the\n`onExit` function is a no-op that returns a no-op `remove` method.\n\n### Options\n\n- `alwaysLast`: Run this handler after any other signal or exit\n  handlers. This causes `process.emit` to be monkeypatched.\n\n### Capturing Signal Exits\n\nIf the handler returns an exact boolean `true`, and the exit is a\ndue to signal, then the signal will be considered handled, and\nwill _not_ trigger a synthetic `process.kill(process.pid,\nsignal)` after firing the `onExit` handlers.\n\nIn this case, it your responsibility as the caller to exit with a\nsignal (for example, by calling `process.kill()`) if you wish to\npreserve the same exit status that would otherwise have occurred.\nIf you do not, then the process will likely exit gracefully with\nstatus 0 at some point, assuming that no other terminating signal\nor other exit trigger occurs.\n\nPrior to calling handlers, the `onExit` machinery is unloaded, so\nany subsequent exits or signals will not be handled, even if the\nsignal is captured and the exit is thus prevented.\n\nNote that numeric code exits may indicate that the process is\nalready committed to exiting, for example due to a fatal\nexception or unhandled promise rejection, and so there is no way to\nprevent it safely.\n\n### Browser Fallback\n\nThe `'signal-exit/browser'` module is the same fallback shim that\njust doesn't do anything, but presents the same function\ninterface.\n\nPatches welcome to add something that hooks onto\n`window.onbeforeunload` or similar, but it might just not be a\nthing that makes sense there.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{5b/2c/6987e21163a72dec9cd8eb7080fdc860cd1c8f90e7ff51849a3d8865861a7f06a3ccebcfd2fa632a2b72285d50f78319e661c395ab55f8875f5edeb15789 → 0c/77/95045869498e41b1e8d1b5ab73fc616a034efdec9e99ece4134489577e9e6c2ae2959459a4786a87aaacaa48467ba8c124ed8fda0f7e135789eb5dde30ae}

@@ -1203,7 +1203,7 @@
   "dist-tags": {
     "latest": "5.2.0"
   },
-  "_rev": "77-d2ac5084948ae5e0",
+  "_rev": "78-6cc8c741ccde0977",
   "_id": "@aws-crypto/crc32c",
   "readme": "# @aws-crypto/crc32c\n\nPure JS implementation of CRC32-C https://en.wikipedia.org/wiki/Cyclic_redundancy_check\n\n## Usage\n\n```\nimport { Crc32c } from '@aws-crypto/crc32c';\n\nconst crc32Digest = (new Crc32c).update(buffer).digest()\n\n```\n\n## Test\n\n`npm test`",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{62/69/678a377c6a6701f787daaec7bd7c8fc9d23d5539d9f81cab3e2361259ca4bb17ba0e10ee70ad0efdc4735aaeb1aab7fa9159a3201d88916efa9303db7c9b → 0d/ca/6408dc76793ceb7a7ca269ba8cab528d0f3fe0657b950d68040a9c0d7ea5feea8729acac804adb47e2ecf445f8e1b68b5a49bad8c359af6480763868fc51}

@@ -13018,7 +13018,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "76-498c5128c336beac",
+  "_rev": "77-5b514a5e9673562b",
   "_id": "@aws-sdk/md5-js",
   "readme": "# @aws-sdk/md5-js\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/md5-js/latest.svg)](https://www.npmjs.com/package/@aws-sdk/md5-js)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/md5-js.svg)](https://www.npmjs.com/package/@aws-sdk/md5-js)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{ac/c6/9f7f8765c22ddb3959ca3985d8f21441ebe3297149552c660693d0586da3e8bf99014260b8b73b393ebaf87ca9176ea17aec9e2c71cb1039c08b9cb9597d → 0e/8f/af68b784976e418d144fc32499ce8b815c5b9148c44938da7fc8a1f05f1bb1c351b4c635eed26b8be16798ee95715724b49e1f1569a725fe9fa991fa20b4}

@@ -969,7 +969,7 @@
   "dist-tags": {
     "latest": "0.11.0"
   },
-  "_rev": "131-c38f013582f002f9",
+  "_rev": "132-bcc8273c35888834",
   "_id": "@pkgjs/parseargs",
   "readme": "<!-- omit in toc -->\n# parseArgs\n\n[![Coverage][coverage-image]][coverage-url]\n\nPolyfill of `util.parseArgs()`\n\n## `util.parseArgs([config])`\n\n<!-- YAML\nadded: v18.3.0\nchanges:\n  - version: REPLACEME\n    pr-url: https://github.com/nodejs/node/pull/43459\n    description: add support for returning detailed parse information\n                 using `tokens` in input `config` and returned properties.\n-->\n\n> Stability: 1 - Experimental\n\n* `config` {Object} Used to provide arguments for parsing and to configure\n  the parser. `config` supports the following properties:\n  * `args` {string\\[]} array of argument strings. **Default:** `process.argv`\n    with `execPath` and `filename` removed.\n  * `options` {Object} Used to describe arguments known to the parser.\n    Keys of `options` are the long names of options and values are an\n    {Object} accepting the following properties:\n    * `type` {string} Type of argument, which must be either `boolean` or `string`.\n    * `multiple` {boolean} Whether this option can be provided multiple\n      times. If `true`, all values will be collected in an array. If\n      `false`, values for the option are last-wins. **Default:** `false`.\n    * `short` {string} A single character alias for the option.\n    * `default` {string | boolean | string\\[] | boolean\\[]} The default option\n      value when it is not set by args. It must be of the same type as the\n      the `type` property. When `multiple` is `true`, it must be an array.\n  * `strict` {boolean} Should an error be thrown when unknown arguments\n    are encountered, or when arguments are passed that do not match the\n    `type` configured in `options`.\n    **Default:** `true`.\n  * `allowPositionals` {boolean} Whether this command accepts positional\n    arguments.\n    **Default:** `false` if `strict` is `true`, otherwise `true`.\n  * `tokens` {boolean} Return the parsed tokens. This is useful for extending\n    the built-in behavior, from adding additional checks through to reprocessing\n    the tokens in different ways.\n    **Default:** `false`.\n\n* Returns: {Object} The parsed command line arguments:\n  * `values` {Object} A mapping of parsed option names with their {string}\n    or {boolean} values.\n  * `positionals` {string\\[]} Positional arguments.\n  * `tokens` {Object\\[] | undefined} See [parseArgs tokens](#parseargs-tokens)\n    section. Only returned if `config` includes `tokens: true`.\n\nProvides a higher level API for command-line argument parsing than interacting\nwith `process.argv` directly. Takes a specification for the expected arguments\nand returns a structured object with the parsed options and positionals.\n\n```mjs\nimport { parseArgs } from 'node:util';\nconst args = ['-f', '--bar', 'b'];\nconst options = {\n  foo: {\n    type: 'boolean',\n    short: 'f'\n  },\n  bar: {\n    type: 'string'\n  }\n};\nconst {\n  values,\n  positionals\n} = parseArgs({ args, options });\nconsole.log(values, positionals);\n// Prints: [Object: null prototype] { foo: true, bar: 'b' } []\n```\n\n```cjs\nconst { parseArgs } = require('node:util');\nconst args = ['-f', '--bar', 'b'];\nconst options = {\n  foo: {\n    type: 'boolean',\n    short: 'f'\n  },\n  bar: {\n    type: 'string'\n  }\n};\nconst {\n  values,\n  positionals\n} = parseArgs({ args, options });\nconsole.log(values, positionals);\n// Prints: [Object: null prototype] { foo: true, bar: 'b' } []\n```\n\n`util.parseArgs` is experimental and behavior may change. Join the\nconversation in [pkgjs/parseargs][] to contribute to the design.\n\n### `parseArgs` `tokens`\n\nDetailed parse information is available for adding custom behaviours by\nspecifying `tokens: true` in the configuration.\nThe returned tokens have properties describing:\n\n* all tokens\n  * `kind` {string} One of 'option', 'positional', or 'option-terminator'.\n  * `index` {number} Index of element in `args` containing token. So the\n    source argument for a token is `args[token.index]`.\n* option tokens\n  * `name` {string} Long name of option.\n  * `rawName` {string} How option used in args, like `-f` of `--foo`.\n  * `value` {string | undefined} Option value specified in args.\n    Undefined for boolean options.\n  * `inlineValue` {boolean | undefined} Whether option value specified inline,\n    like `--foo=bar`.\n* positional tokens\n  * `value` {string} The value of the positional argument in args (i.e. `args[index]`).\n* option-terminator token\n\nThe returned tokens are in the order encountered in the input args. Options\nthat appear more than once in args produce a token for each use. Short option\ngroups like `-xy` expand to a token for each option. So `-xxx` produces\nthree tokens.\n\nFor example to use the returned tokens to add support for a negated option\nlike `--no-color`, the tokens can be reprocessed to change the value stored\nfor the negated option.\n\n```mjs\nimport { parseArgs } from 'node:util';\n\nconst options = {\n  'color': { type: 'boolean' },\n  'no-color': { type: 'boolean' },\n  'logfile': { type: 'string' },\n  'no-logfile': { type: 'boolean' },\n};\nconst { values, tokens } = parseArgs({ options, tokens: true });\n\n// Reprocess the option tokens and overwrite the returned values.\ntokens\n  .filter((token) => token.kind === 'option')\n  .forEach((token) => {\n    if (token.name.startsWith('no-')) {\n      // Store foo:false for --no-foo\n      const positiveName = token.name.slice(3);\n      values[positiveName] = false;\n      delete values[token.name];\n    } else {\n      // Resave value so last one wins if both --foo and --no-foo.\n      values[token.name] = token.value ?? true;\n    }\n  });\n\nconst color = values.color;\nconst logfile = values.logfile ?? 'default.log';\n\nconsole.log({ logfile, color });\n```\n\n```cjs\nconst { parseArgs } = require('node:util');\n\nconst options = {\n  'color': { type: 'boolean' },\n  'no-color': { type: 'boolean' },\n  'logfile': { type: 'string' },\n  'no-logfile': { type: 'boolean' },\n};\nconst { values, tokens } = parseArgs({ options, tokens: true });\n\n// Reprocess the option tokens and overwrite the returned values.\ntokens\n  .filter((token) => token.kind === 'option')\n  .forEach((token) => {\n    if (token.name.startsWith('no-')) {\n      // Store foo:false for --no-foo\n      const positiveName = token.name.slice(3);\n      values[positiveName] = false;\n      delete values[token.name];\n    } else {\n      // Resave value so last one wins if both --foo and --no-foo.\n      values[token.name] = token.value ?? true;\n    }\n  });\n\nconst color = values.color;\nconst logfile = values.logfile ?? 'default.log';\n\nconsole.log({ logfile, color });\n```\n\nExample usage showing negated options, and when an option is used\nmultiple ways then last one wins.\n\n```console\n$ node negate.js\n{ logfile: 'default.log', color: undefined }\n$ node negate.js --no-logfile --no-color\n{ logfile: false, color: false }\n$ node negate.js --logfile=test.log --color\n{ logfile: 'test.log', color: true }\n$ node negate.js --no-logfile --logfile=test.log --color --no-color\n{ logfile: 'test.log', color: false }\n```\n\n-----\n\n<!-- omit in toc -->\n## Table of Contents\n- [`util.parseArgs([config])`](#utilparseargsconfig)\n- [Scope](#scope)\n- [Version Matchups](#version-matchups)\n- [🚀 Getting Started](#-getting-started)\n- [🙌 Contributing](#-contributing)\n- [💡 `process.mainArgs` Proposal](#-processmainargs-proposal)\n  - [Implementation:](#implementation)\n- [📃 Examples](#-examples)\n- [F.A.Qs](#faqs)\n- [Links & Resources](#links--resources)\n\n-----\n\n## Scope\n\nIt is already possible to build great arg parsing modules on top of what Node.js provides; the prickly API is abstracted away by these modules. Thus, process.parseArgs() is not necessarily intended for library authors; it is intended for developers of simple CLI tools, ad-hoc scripts, deployed Node.js applications, and learning materials.\n\nIt is exceedingly difficult to provide an API which would both be friendly to these Node.js users while being extensible enough for libraries to build upon. We chose to prioritize these use cases because these are currently not well-served by Node.js' API.\n\n----\n\n## Version Matchups\n\n| Node.js | @pkgjs/parseArgs |\n| -- | -- |\n| [v18.3.0](https://nodejs.org/docs/latest-v18.x/api/util.html#utilparseargsconfig) | [v0.9.1](https://github.com/pkgjs/parseargs/tree/v0.9.1#utilparseargsconfig) |\n| [v16.17.0](https://nodejs.org/dist/latest-v16.x/docs/api/util.html#utilparseargsconfig), [v18.7.0](https://nodejs.org/docs/latest-v18.x/api/util.html#utilparseargsconfig) | [0.10.0](https://github.com/pkgjs/parseargs/tree/v0.10.0#utilparseargsconfig) |\n\n----\n\n## 🚀 Getting Started\n\n1. **Install dependencies.**\n\n   ```bash\n   npm install\n   ```\n\n2. **Open the index.js file and start editing!**\n\n3. **Test your code by calling parseArgs through our test file**\n\n   ```bash\n   npm test\n   ```\n\n----\n\n## 🙌 Contributing\n\nAny person who wants to contribute to the initiative is welcome! Please first read the [Contributing Guide](CONTRIBUTING.md)\n\nAdditionally, reading the [`Examples w/ Output`](#-examples-w-output) section of this document will be the best way to familiarize yourself with the target expected behavior for parseArgs() once it is fully implemented.\n\nThis package was implemented using [tape](https://www.npmjs.com/package/tape) as its test harness.\n\n----\n\n## 💡 `process.mainArgs` Proposal\n\n> Note: This can be moved forward independently of the `util.parseArgs()` proposal/work.\n\n### Implementation:\n\n```javascript\nprocess.mainArgs = process.argv.slice(process._exec ? 1 : 2)\n```\n\n----\n\n## 📃 Examples\n\n```js\nconst { parseArgs } = require('@pkgjs/parseargs');\n```\n\n```js\nconst { parseArgs } = require('@pkgjs/parseargs');\n// specify the options that may be used\nconst options = {\n  foo: { type: 'string'},\n  bar: { type: 'boolean' },\n};\nconst args = ['--foo=a', '--bar'];\nconst { values, positionals } = parseArgs({ args, options });\n// values = { foo: 'a', bar: true }\n// positionals = []\n```\n\n```js\nconst { parseArgs } = require('@pkgjs/parseargs');\n// type:string & multiple\nconst options = {\n  foo: {\n    type: 'string',\n    multiple: true,\n  },\n};\nconst args = ['--foo=a', '--foo', 'b'];\nconst { values, positionals } = parseArgs({ args, options });\n// values = { foo: [ 'a', 'b' ] }\n// positionals = []\n```\n\n```js\nconst { parseArgs } = require('@pkgjs/parseargs');\n// shorts\nconst options = {\n  foo: {\n    short: 'f',\n    type: 'boolean'\n  },\n};\nconst args = ['-f', 'b'];\nconst { values, positionals } = parseArgs({ args, options, allowPositionals: true });\n// values = { foo: true }\n// positionals = ['b']\n```\n\n```js\nconst { parseArgs } = require('@pkgjs/parseargs');\n// unconfigured\nconst options = {};\nconst args = ['-f', '--foo=a', '--bar', 'b'];\nconst { values, positionals } = parseArgs({ strict: false, args, options, allowPositionals: true });\n// values = { f: true, foo: 'a', bar: true }\n// positionals = ['b']\n```\n\n----\n\n## F.A.Qs\n\n- Is `cmd --foo=bar baz` the same as `cmd baz --foo=bar`?\n  - yes\n- Does the parser execute a function?\n  - no\n- Does the parser execute one of several functions, depending on input?\n  - no\n- Can subcommands take options that are distinct from the main command?\n  - no\n- Does it output generated help when no options match?\n  - no\n- Does it generated short usage?  Like: `usage: ls [-ABCFGHLOPRSTUWabcdefghiklmnopqrstuwx1] [file ...]`\n  - no (no usage/help at all)\n- Does the user provide the long usage text?  For each option?  For the whole command?\n  - no\n- Do subcommands (if implemented) have their own usage output?\n  - no\n- Does usage print if the user runs `cmd --help`?\n  - no\n- Does it set `process.exitCode`?\n  - no\n- Does usage print to stderr or stdout?\n  - N/A\n- Does it check types?  (Say, specify that an option is a boolean, number, etc.)\n  - no\n- Can an option have more than one type?  (string or false, for example)\n  - no\n- Can the user define a type?  (Say, `type: path` to call `path.resolve()` on the argument.)\n  - no\n- Does a `--foo=0o22` mean 0, 22, 18, or \"0o22\"?\n  - `\"0o22\"`\n- Does it coerce types?\n  - no\n- Does `--no-foo` coerce to `--foo=false`?  For all options?  Only boolean options?\n  - no, it sets `{values:{'no-foo': true}}`\n- Is `--foo` the same as `--foo=true`?  Only for known booleans?  Only at the end?\n  - no, they are not the same. There is no special handling of `true` as a value so it is just another string.\n- Does it read environment variables?  Ie, is `FOO=1 cmd` the same as `cmd --foo=1`?\n  - no\n- Do unknown arguments raise an error?  Are they parsed?  Are they treated as positional arguments?\n  - no, they are parsed, not treated as positionals\n- Does `--` signal the end of options?\n  - yes\n- Is `--` included as a positional?\n  - no\n- Is `program -- foo` the same as `program foo`?\n  - yes, both store `{positionals:['foo']}`\n- Does the API specify whether a `--` was present/relevant?\n  - no\n- Is `-bar` the same as `--bar`?\n  - no, `-bar` is a short option or options, with expansion logic that follows the\n    [Utility Syntax Guidelines in POSIX.1-2017](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html). `-bar` expands to `-b`, `-a`, `-r`.\n- Is `---foo` the same as `--foo`?\n  - no\n  - the first is a long option named `'-foo'`\n  - the second is a long option named `'foo'`\n- Is `-` a positional? ie, `bash some-test.sh | tap -`\n  - yes\n\n## Links & Resources\n\n* [Initial Tooling Issue](https://github.com/nodejs/tooling/issues/19)\n* [Initial Proposal](https://github.com/nodejs/node/pull/35015)\n* [parseArgs Proposal](https://github.com/nodejs/node/pull/42675)\n\n[coverage-image]: https://img.shields.io/nycrc/pkgjs/parseargs\n[coverage-url]: https://github.com/pkgjs/parseargs/blob/main/.nycrc\n[pkgjs/parseargs]: https://github.com/pkgjs/parseargs",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{c7/e6/e0bddcead92e9a70b5690f4d4413aa9a74a184ae1092fea91a5fc793fcefaa07630ad7cfbf0e855d9576e743b94fca671ed4486e608e2e0a2493902d1cc6 → 10/4b/ad5cc1a8fef25adec8747fd289929c60218b72174c36f7b78d3c47df2fcd5a1812107e013b56ffba8c2f23c16bf56f79430af74b07bce1381249c8b64336}

@@ -4551,7 +4551,7 @@
     "latest": "7.0.6",
     "6x": "6.0.6"
   },
-  "_rev": "1839-83800b3957ca63c2",
+  "_rev": "1840-eb5f5bbeb85f799c",
   "_id": "cross-spawn",
   "readme": "",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{ec/68/03d8f3c40980e9c9b089f7006e49ab474e4594e2f7232a123109f6606ce0d47f60b14b92b4a73dd032e6390aa48e04e0cd41ede6f68eba0cb5c44dff57f2 → 11/82/23b28ef730d6ce353137521b7f5ddb6d2ae727f368220b5ee3f64f7037d77a89b1f171a960ae5ea75e2370ca775db4173a2ceccc32331617550658513e2f}

@@ -4885,7 +4885,7 @@
   "dist-tags": {
     "latest": "3.1.7"
   },
-  "_rev": "502-457ba3c7e1e175ec",
+  "_rev": "503-29312bb79c492e1e",
   "_id": "tar-stream",
   "readme": "# tar-stream\n\ntar-stream is a streaming tar parser and generator and nothing else. It operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.\n\nNote that you still need to gunzip your data if you have a `.tar.gz`. We recommend using [gunzip-maybe](https://github.com/mafintosh/gunzip-maybe) in conjunction with this.\n\n```\nnpm install tar-stream\n```\n\n[![build status](https://secure.travis-ci.org/mafintosh/tar-stream.png)](http://travis-ci.org/mafintosh/tar-stream)\n[![License](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)\n\n## Usage\n\ntar-stream exposes two streams, [pack](https://github.com/mafintosh/tar-stream#packing) which creates tarballs and [extract](https://github.com/mafintosh/tar-stream#extracting) which extracts tarballs. To [modify an existing tarball](https://github.com/mafintosh/tar-stream#modifying-existing-tarballs) use both.\n\n\nIt implementes USTAR with additional support for pax extended headers. It should be compatible with all popular tar distributions out there (gnutar, bsdtar etc)\n\n## Related\n\nIf you want to pack/unpack directories on the file system check out [tar-fs](https://github.com/mafintosh/tar-fs) which provides file system bindings to this module.\n\n## Packing\n\nTo create a pack stream use `tar.pack()` and call `pack.entry(header, [callback])` to add tar entries.\n\n``` js\nconst tar = require('tar-stream')\nconst pack = tar.pack() // pack is a stream\n\n// add a file called my-test.txt with the content \"Hello World!\"\npack.entry({ name: 'my-test.txt' }, 'Hello World!')\n\n// add a file called my-stream-test.txt from a stream\nconst entry = pack.entry({ name: 'my-stream-test.txt', size: 11 }, function(err) {\n  // the stream was added\n  // no more entries\n  pack.finalize()\n})\n\nentry.write('hello')\nentry.write(' ')\nentry.write('world')\nentry.end()\n\n// pipe the pack stream somewhere\npack.pipe(process.stdout)\n```\n\n## Extracting\n\nTo extract a stream use `tar.extract()` and listen for `extract.on('entry', (header, stream, next) )`\n\n``` js\nconst extract = tar.extract()\n\nextract.on('entry', function (header, stream, next) {\n  // header is the tar header\n  // stream is the content body (might be an empty stream)\n  // call next when you are done with this entry\n\n  stream.on('end', function () {\n    next() // ready for next entry\n  })\n\n  stream.resume() // just auto drain the stream\n})\n\nextract.on('finish', function () {\n  // all entries read\n})\n\npack.pipe(extract)\n```\n\nThe tar archive is streamed sequentially, meaning you **must** drain each entry's stream as you get them or else the main extract stream will receive backpressure and stop reading.\n\n## Extracting as an async iterator\n\nThe extraction stream in addition to being a writable stream is also an async iterator\n\n``` js\nconst extract = tar.extract()\n\nsomeStream.pipe(extract)\n\nfor await (const entry of extract) {\n  entry.header // the tar header\n  entry.resume() // the entry is the stream also\n}\n```\n\n## Headers\n\nThe header object using in `entry` should contain the following properties.\nMost of these values can be found by stat'ing a file.\n\n``` js\n{\n  name: 'path/to/this/entry.txt',\n  size: 1314,        // entry size. defaults to 0\n  mode: 0o644,       // entry mode. defaults to to 0o755 for dirs and 0o644 otherwise\n  mtime: new Date(), // last modified date for entry. defaults to now.\n  type: 'file',      // type of entry. defaults to file. can be:\n                     // file | link | symlink | directory | block-device\n                     // character-device | fifo | contiguous-file\n  linkname: 'path',  // linked file name\n  uid: 0,            // uid of entry owner. defaults to 0\n  gid: 0,            // gid of entry owner. defaults to 0\n  uname: 'maf',      // uname of entry owner. defaults to null\n  gname: 'staff',    // gname of entry owner. defaults to null\n  devmajor: 0,       // device major version. defaults to 0\n  devminor: 0        // device minor version. defaults to 0\n}\n```\n\n## Modifying existing tarballs\n\nUsing tar-stream it is easy to rewrite paths / change modes etc in an existing tarball.\n\n``` js\nconst extract = tar.extract()\nconst pack = tar.pack()\nconst path = require('path')\n\nextract.on('entry', function (header, stream, callback) {\n  // let's prefix all names with 'tmp'\n  header.name = path.join('tmp', header.name)\n  // write the new entry to the pack stream\n  stream.pipe(pack.entry(header, callback))\n})\n\nextract.on('finish', function () {\n  // all entries done - lets finalize it\n  pack.finalize()\n})\n\n// pipe the old tarball to the extractor\noldTarballStream.pipe(extract)\n\n// pipe the new tarball the another stream\npack.pipe(newTarballStream)\n```\n\n## Saving tarball to fs\n\n\n``` js\nconst fs = require('fs')\nconst tar = require('tar-stream')\n\nconst pack = tar.pack() // pack is a stream\nconst path = 'YourTarBall.tar'\nconst yourTarball = fs.createWriteStream(path)\n\n// add a file called YourFile.txt with the content \"Hello World!\"\npack.entry({ name: 'YourFile.txt' }, 'Hello World!', function (err) {\n  if (err) throw err\n  pack.finalize()\n})\n\n// pipe the pack stream to your file\npack.pipe(yourTarball)\n\nyourTarball.on('close', function () {\n  console.log(path + ' has been written')\n  fs.stat(path, function(err, stats) {\n    if (err) throw err\n    console.log(stats)\n    console.log('Got file info successfully!')\n  })\n})\n```\n\n## Performance\n\n[See tar-fs for a performance comparison with node-tar](https://github.com/mafintosh/tar-fs/blob/master/README.md#performance)\n\n# License\n\nMIT",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{e4/06/29463e8f5a59854f85a2d2e375e12a209b599135d9a3a05612391646202650e28018187ecf090b2ffeac7070d6ecbc4861212937c01e7d1500ea7f8ac52f → 13/e5/0b73930a433ba0494ba63acbedefec14683f9a36afcaf8fa3cf2ae737a1799ff8f6c39e55ff95040de99fa67bfc682b412dbffd95160d46898f5d8a2d1b3}

@@ -4366,7 +4366,7 @@
     "latest": "4.2.11",
     "old": "3.0.12"
   },
-  "_rev": "2164-01227c88be716bb8",
+  "_rev": "2165-c53ee8489cd03be2",
   "_id": "graceful-fs",
   "readme": "# graceful-fs\n\ngraceful-fs functions as a drop-in replacement for the fs module,\nmaking various improvements.\n\nThe improvements are meant to normalize behavior across different\nplatforms and environments, and to make filesystem access more\nresilient to errors.\n\n## Improvements over [fs module](https://nodejs.org/api/fs.html)\n\n* Queues up `open` and `readdir` calls, and retries them once\n  something closes if there is an EMFILE error from too many file\n  descriptors.\n* fixes `lchmod` for Node versions prior to 0.6.2.\n* implements `fs.lutimes` if possible. Otherwise it becomes a noop.\n* ignores `EINVAL` and `EPERM` errors in `chown`, `fchown` or\n  `lchown` if the user isn't root.\n* makes `lchmod` and `lchown` become noops, if not available.\n* retries reading a file if `read` results in EAGAIN error.\n\nOn Windows, it retries renaming a file for up to one second if `EACCESS`\nor `EPERM` error occurs, likely because antivirus software has locked\nthe directory.\n\n## USAGE\n\n```javascript\n// use just like fs\nvar fs = require('graceful-fs')\n\n// now go and do stuff with it...\nfs.readFile('some-file-or-whatever', (err, data) => {\n  // Do stuff here.\n})\n```\n\n## Sync methods\n\nThis module cannot intercept or handle `EMFILE` or `ENFILE` errors from sync\nmethods.  If you use sync methods which open file descriptors then you are\nresponsible for dealing with any errors.\n\nThis is a known limitation, not a bug.\n\n## Global Patching\n\nIf you want to patch the global fs module (or any other fs-like\nmodule) you can do this:\n\n```javascript\n// Make sure to read the caveat below.\nvar realFs = require('fs')\nvar gracefulFs = require('graceful-fs')\ngracefulFs.gracefulify(realFs)\n```\n\nThis should only ever be done at the top-level application layer, in\norder to delay on EMFILE errors from any fs-using dependencies.  You\nshould **not** do this in a library, because it can cause unexpected\ndelays in other parts of the program.\n\n## Changes\n\nThis module is fairly stable at this point, and used by a lot of\nthings.  That being said, because it implements a subtle behavior\nchange in a core part of the node API, even modest changes can be\nextremely breaking, and the versioning is thus biased towards\nbumping the major when in doubt.\n\nThe main change between major versions has been switching between\nproviding a fully-patched `fs` module vs monkey-patching the node core\nbuiltin, and the approach by which a non-monkey-patched `fs` was\ncreated.\n\nThe goal is to trade `EMFILE` errors for slower fs operations.  So, if\nyou try to open a zillion files, rather than crashing, `open`\noperations will be queued up and wait for something else to `close`.\n\nThere are advantages to each approach.  Monkey-patching the fs means\nthat no `EMFILE` errors can possibly occur anywhere in your\napplication, because everything is using the same core `fs` module,\nwhich is patched.  However, it can also obviously cause undesirable\nside-effects, especially if the module is loaded multiple times.\n\nImplementing a separate-but-identical patched `fs` module is more\nsurgical (and doesn't run the risk of patching multiple times), but\nalso imposes the challenge of keeping in sync with the core module.\n\nThe current approach loads the `fs` module, and then creates a\nlookalike object that has all the same methods, except a few that are\npatched.  It is safe to use in all versions of Node from 0.8 through\n7.0.\n\n### v4\n\n* Do not monkey-patch the fs module.  This module may now be used as a\n  drop-in dep, and users can opt into monkey-patching the fs builtin\n  if their app requires it.\n\n### v3\n\n* Monkey-patch fs, because the eval approach no longer works on recent\n  node.\n* fixed possible type-error throw if rename fails on windows\n* verify that we *never* get EMFILE errors\n* Ignore ENOSYS from chmod/chown\n* clarify that graceful-fs must be used as a drop-in\n\n### v2.1.0\n\n* Use eval rather than monkey-patching fs.\n* readdir: Always sort the results\n* win32: requeue a file if error has an OK status\n\n### v2.0\n\n* A return to monkey patching\n* wrap process.cwd\n\n### v1.1\n\n* wrap readFile\n* Wrap fs.writeFile.\n* readdir protection\n* Don't clobber the fs builtin\n* Handle fs.read EAGAIN errors by trying again\n* Expose the curOpen counter\n* No-op lchown/lchmod if not implemented\n* fs.rename patch only for win32\n* Patch fs.rename to handle AV software on Windows\n* Close #4 Chown should not fail on einval or eperm if non-root\n* Fix isaacs/fstream#1 Only wrap fs one time\n* Fix #3 Start at 1024 max files, then back off on EMFILE\n* lutimes that doens't blow up on Linux\n* A full on-rewrite using a queue instead of just swallowing the EMFILE error\n* Wrap Read/Write streams as well\n\n### 1.0\n\n* Update engines for node 0.6\n* Be lstat-graceful on Windows\n* first",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{eb/71/42f7ad2bbeadd5232b80268aa911ec6766159202c12ebb8fd4c8a5347b4cf71e3cc803b8c88896402c4fca5e9d570074293182e4048b717f9bfc606d4564 → 13/fc/be6088deb8dfc91e17c3ecbe7710e326e15eb6ca6281d8f6fd616bac5aa6a0dec7fcfbade6f591d98ca07fbe55cad5c6a46a2523dcd9e17a60baafaa0928}

@@ -1255,7 +1255,7 @@
     "latest": "3.0.0",
     "next": "3.0.0"
   },
-  "_rev": "208-55d5835b7547f417",
+  "_rev": "209-ce2ae82f69511d0d",
   "_id": "abort-controller",
   "readme": "# abort-controller\n\n[![npm version](https://img.shields.io/npm/v/abort-controller.svg)](https://www.npmjs.com/package/abort-controller)\n[![Downloads/month](https://img.shields.io/npm/dm/abort-controller.svg)](http://www.npmtrends.com/abort-controller)\n[![Build Status](https://travis-ci.org/mysticatea/abort-controller.svg?branch=master)](https://travis-ci.org/mysticatea/abort-controller)\n[![Coverage Status](https://codecov.io/gh/mysticatea/abort-controller/branch/master/graph/badge.svg)](https://codecov.io/gh/mysticatea/abort-controller)\n[![Dependency Status](https://david-dm.org/mysticatea/abort-controller.svg)](https://david-dm.org/mysticatea/abort-controller)\n\nAn implementation of [WHATWG AbortController interface](https://dom.spec.whatwg.org/#interface-abortcontroller).\n\n```js\nimport AbortController from \"abort-controller\"\n\nconst controller = new AbortController()\nconst signal = controller.signal\n\nsignal.addEventListener(\"abort\", () => {\n    console.log(\"aborted!\")\n})\n\ncontroller.abort()\n```\n\n> https://jsfiddle.net/1r2994qp/1/\n\n## 💿 Installation\n\nUse [npm](https://www.npmjs.com/) to install then use a bundler.\n\n```\nnpm install abort-controller\n```\n\nOr download from [`dist` directory](./dist).\n\n- [dist/abort-controller.mjs](dist/abort-controller.mjs) ... ES modules version.\n- [dist/abort-controller.js](dist/abort-controller.js) ... Common JS version.\n- [dist/abort-controller.umd.js](dist/abort-controller.umd.js) ... UMD (Universal Module Definition) version. This is transpiled by [Babel](https://babeljs.io/) for IE 11.\n\n## 📖 Usage\n\n### Basic\n\n```js\nimport AbortController from \"abort-controller\"\n// or\nconst AbortController = require(\"abort-controller\")\n\n// or UMD version defines a global variable:\nconst AbortController = window.AbortControllerShim\n```\n\nIf your bundler recognizes `browser` field of `package.json`, the imported `AbortController` is the native one and it doesn't contain shim (even if the native implementation was nothing).\nIf you wanted to polyfill `AbortController` for IE, use `abort-controller/polyfill`.\n\n### Polyfilling\n\nImporting `abort-controller/polyfill` assigns the `AbortController` shim to the `AbortController` global variable if the native implementation was nothing.\n\n```js\nimport \"abort-controller/polyfill\"\n// or\nrequire(\"abort-controller/polyfill\")\n```\n\n### API\n\n#### AbortController\n\n> https://dom.spec.whatwg.org/#interface-abortcontroller\n\n##### controller.signal\n\nThe [AbortSignal](https://dom.spec.whatwg.org/#interface-AbortSignal) object which is associated to this controller.\n\n##### controller.abort()\n\nNotify `abort` event to listeners that the `signal` has.\n\n## 📰 Changelog\n\n- See [GitHub releases](https://github.com/mysticatea/abort-controller/releases).\n\n## 🍻 Contributing\n\nContributing is welcome ❤️\n\nPlease use GitHub issues/PRs.\n\n### Development tools\n\n- `npm install` installs dependencies for development.\n- `npm test` runs tests and measures code coverage.\n- `npm run clean` removes temporary files of tests.\n- `npm run coverage` opens code coverage of the previous test with your default browser.\n- `npm run lint` runs ESLint.\n- `npm run build` generates `dist` codes.\n- `npm run watch` runs tests on each file change.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{09/fe/c7ab0705f5791f589f48caa7fcac54c1b463585a1c6dc5f819dae2b958df93663f49aba213811959fad42b736d2884f8ebdb5cadc62e09226ec691e03f91 → 15/7a/7d55752c8ab7947b531f291936af9871cb1eeaffb3bc772e14e75488dcce6c8e07d73ba418ae7ccaf7e11fd70489553c641460c709a337b81c0cca802ba0}

@@ -14835,7 +14835,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "90-bc2650c066a334a5",
+  "_rev": "91-d0079de89cd7d287",
   "_id": "@aws-sdk/node-http-handler",
   "readme": "# @aws-sdk/node-http-handler\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/node-http-handler/latest.svg)](https://www.npmjs.com/package/@aws-sdk/node-http-handler)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/node-http-handler.svg)](https://www.npmjs.com/package/@aws-sdk/node-http-handler)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{69/ad/302cb5fa883e77833c4571728c4fbb09bdef85b728d26b6b57c3043704cdcfa07a9e45204b95674970771f0e8ec4f731fb8b7ec5cc66fad5cde1f711afee → 15/be/d8521af96403178344f562ddd6abb94fa09d8e9040bc93928fa6514eaf5078636aa95087fb5c8c8cc2e9b77db4071ea4eeed7b392b836693c5fe8dc5b96a}

@@ -15715,7 +15715,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "96-5157e4d3fc3eeef3",
+  "_rev": "97-b6f334828992fe80",
   "_id": "@aws-sdk/types",
   "readme": "# @aws-sdk/types\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/types/latest.svg)](https://www.npmjs.com/package/@aws-sdk/types)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/types.svg)](https://www.npmjs.com/package/@aws-sdk/types)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{aa/1f/23da83ebbfafe19722591653f957886ec9413773107c76473b8745d9f9cd6d842345dfa37863e90b4679a98e2b8e4a9cc4d789fda231d1b8a0ee0201e685 → 16/94/2a23c4dc4408d6647a41a78c6fe0a0e8ba6a37090b834d2f53aa428bee26964e7e4bdf58772c0054135ab1b0e560dcb0169e9aaae18c898261e8b4e38de9}

@@ -11391,7 +11391,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "89-20e8cab01ce2553a",
+  "_rev": "90-c249688e3bb4bb4b",
   "_id": "@aws-sdk/middleware-serde",
   "readme": "# @aws-sdk/middleware-serde\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-serde/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-serde)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-serde.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-serde)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0a/50/fa08ab707d404d68770652802e099bb6d1c5ad31e09140f39a7c36453230cf5d6b210ba133d1efc6d0f0b522285d9137e3b352d611bd24e7fc601a06955b → 17/14/5ffc5eb423631bf1084c6098e0e3ed91523ef2dd398f228add36cc44ffd59485d786887b9b1d806f2276132a5c93e69de5c12be16b114a9f197ac45186e2}

@@ -236,7 +236,7 @@
   "dist-tags": {
     "latest": "1.0.2"
   },
-  "_rev": "1723-01893ba71326c222",
+  "_rev": "1724-6dae5339c6fa6691",
   "_id": "wrappy",
   "readme": "# wrappy\n\nCallback wrapping utility\n\n## USAGE\n\n```javascript\nvar wrappy = require(\"wrappy\")\n\n// var wrapper = wrappy(wrapperFunction)\n\n// make sure a cb is called only once\n// See also: http://npm.im/once for this specific use case\nvar once = wrappy(function (cb) {\n  var called = false\n  return function () {\n    if (called) return\n    called = true\n    return cb.apply(this, arguments)\n  }\n})\n\nfunction printBoo () {\n  console.log('boo')\n}\n// has some rando property\nprintBoo.iAmBooPrinter = true\n\nvar onlyPrintOnce = once(printBoo)\n\nonlyPrintOnce() // prints 'boo'\nonlyPrintOnce() // does nothing\n\n// random property is retained!\nassert.equal(onlyPrintOnce.iAmBooPrinter, true)\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{f1/5a/9369602fb0f4154327f85f2da2620ea2ab9f4ef380af98275b65ccdf99b5cf9ebd857fd6eb63026152a3f785a5640f0cae25c9b0005d34212b81b47a6991 → 17/2d/f93a972fb4a5ce408b51c1fc7068c3ba3cc3fc377f22e509672d32726c83300f5dc760dd12de4c175557c35a88addede852686dbbe4a72268b9cc5e8e6fd}

@@ -2776,7 +2776,7 @@
   "dist-tags": {
     "latest": "3.0.1"
   },
-  "_rev": "2425-400597b6602a830c",
+  "_rev": "2426-e0ce8b9de4576fcc",
   "_id": "color-convert",
   "readme": "# color-convert\n\nColor-convert is a color conversion library for JavaScript and node.\nIt converts all ways between `rgb`, `hsl`, `hsv`, `hwb`, `cmyk`, `ansi`, `ansi16`, `hex` strings, and CSS `keyword`s (will round to closest):\n\n```js\nimport convert from 'color-convert';\n\nconvert.rgb.hsl(140, 200, 100);             // [96, 48, 59]\nconvert.keyword.rgb('blue');                // [0, 0, 255]\n\nconst rgbChannels = convert.rgb.channels;     // 3\nconst cmykChannels = convert.cmyk.channels;   // 4\nconst ansiChannels = convert.ansi16.channels; // 1\n```\n\n# Install\n\n```sh\nnpm install color-convert\n```\n\n# API\n\nSimply get the property of the _from_ and _to_ conversion that you're looking for.\n\nAll functions have a rounded and unrounded variant. By default, return values are rounded. To get the unrounded (raw) results, simply tack on `.raw` to the function.\n\nAll 'from' functions have a hidden property called `.channels` that indicates the number of channels the function expects (not including alpha).\n\n```js\nimport convert from 'color-convert';\n\n// Hex to LAB\nconvert.hex.lab('DEADBF');         // [ 76, 21, -2 ]\nconvert.hex.lab.raw('DEADBF');     // [ 75.56213190997677, 20.653827952644754, -2.290532499330533 ]\n\n// RGB to CMYK\nconvert.rgb.cmyk(167, 255, 4);     // [ 35, 0, 98, 0 ]\nconvert.rgb.cmyk.raw(167, 255, 4); // [ 34.509803921568626, 0, 98.43137254901961, 0 ]\n```\n\n### Arrays\nAll functions that accept multiple arguments also support passing an array.\n\nNote that this does **not** apply to functions that convert from a color that only requires one value (e.g. `keyword`, `ansi256`, `hex`, etc.)\n\n```js\nimport convert from 'color-convert';\n\nconvert.rgb.hex(123, 45, 67);      // '7B2D43'\nconvert.rgb.hex([123, 45, 67]);    // '7B2D43'\n```\n\n## Routing\n\nConversions that don't have an _explicitly_ defined conversion (in [conversions.js](conversions.js)), but can be converted by means of sub-conversions (e.g. XYZ -> **RGB** -> CMYK), are automatically routed together. This allows just about any color model supported by `color-convert` to be converted to any other model, so long as a sub-conversion path exists. This is also true for conversions requiring more than one step in between (e.g. LCH -> **LAB** -> **XYZ** -> **RGB** -> Hex).\n\nKeep in mind that extensive conversions _may_ result in a loss of precision, and exist only to be complete. For a list of \"direct\" (single-step) conversions, see [conversions.js](conversions.js).\n\n## Color Space Scales\nConversions rely on an agreed upon 'full-scale' value for each of the channels. Listed here are those values for the most common color spaces\n\n### rgb\nchannel | full-scale value\n---|---\nr | 255\ng | 255\nb | 255\n\n### hsl\nchannel | full-scale value\n---|---\nh | 360\ns | 100\nl | 100\n\n### hsv\nchannel | full-scale value\n---|---\nh | 360\ns | 100\nv | 100\n\n### hwb\nchannel | full-scale value\n---|---\nh | 360\nw | 100\nb | 100\n\n### cmyk\nchannel | full-scale value\n---|---\nc | 100\nm | 100\ny | 100\nk | 100\n\n### hex\nchannel | full-scale value\n---|---\nhex | ```0xffffff```\n\n### keyword\nchannel | value\n---|---\nname | any key from [color-name](https://github.com/colorjs/color-name/blob/master/index.js)\n\n### apple\nchannel | full-scale value\n---|---\n0 | 65535\n1 | 65535\n2 | 65535\n\n### gray\nchannel | full-scale value\n---|---\ngray | 100\n\n# Contribute\n\nIf there is a new model you would like to support, or want to add a direct conversion between two existing models, please send us a pull request.\n\n# License\nCopyright © 2011-2016, Heather Arthur.\nCopyright © 2016-2021, Josh Junon.\n\nLicensed under the [MIT License](LICENSE).",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{86/3f/08a4cccfc4edb2583f535619cc833ea3086b4ad686b74099c7c6f834dd9fbeb37e05cc8fae2c2435113f2d9d2980461a9f4d7764c22d058fa11c2c203ec3 → 17/4a/1815f2fd8105d644f99eb38c5ec4de71de8aacd9b51a4411d644fa5382baf57989b8e181a0c6c446cff314d384f544b15bc0d5098a0f3b885b62e9378efc}

@@ -16449,7 +16449,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "3.5.1-rc.0"
   },
-  "_rev": "89-73612f4bdfd22d5a",
+  "_rev": "90-b33c1373d6c3eda8",
   "_id": "@aws-sdk/config-resolver",
   "readme": "# @aws-sdk/config-resolver\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/config-resolver/latest.svg)](https://www.npmjs.com/package/@aws-sdk/config-resolver)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/config-resolver.svg)](https://www.npmjs.com/package/@aws-sdk/config-resolver)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{af/4c/bacaf147eae7bf894486b267c8bf8218b0f4738ef7671c93f63ecd95cc9413da0c36c76b35d723e847e596c2cfdc6c23cf811e8baf4ccbb33631768d9e84 → 17/c3/d3f98ec81e9dc4c851a820d19f1a58debe6fcc6573c72ad16e1ce1819b651a021c0c1b4cf609440dced3d6b527cbfbf5008fc10be3287924558ffe234620}

@@ -11733,7 +11733,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "76-e83edc139ba9c7e9",
+  "_rev": "77-675e74108804ccc0",
   "_id": "@aws-sdk/eventstream-serde-browser",
   "readme": "# @aws-sdk/eventstream-serde-browser\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/eventstream-serde-browser/latest.svg)](https://www.npmjs.com/package/@aws-sdk/eventstream-serde-browser)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/eventstream-serde-browser.svg)](https://www.npmjs.com/package/@aws-sdk/eventstream-serde-browser)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{8e/f2/40dd810e7b44dd0df54bc1bb9e692f0db2936af718aa4e78154b96e161a745192f508dc843a28dd757c757ad1443064553c44110cb8b97dd9f6006c18c48 → 17/d3/c90106e98bfdfd3a88c4a904d60f77c6f3fa2a0575bf2c0eb7f5500bc9c95faf9137ab9a3ac9445ccbf9d5b3040c1b97fb9c90a1e0d223fb46f40c317cc2}

@@ -5782,7 +5782,7 @@
   "dist-tags": {
     "latest": "3.374.0"
   },
-  "_rev": "90-4ecadb3e0180ca0a",
+  "_rev": "91-6ef51e416d49cc07",
   "_id": "@aws-sdk/util-middleware",
   "readme": "# @aws-sdk/util-middleware\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-middleware/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-middleware)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-middleware.svg)](https://www.npmjs.com/package/@aws-sdk/util-middleware)\n\n> An internal package\n\nThis package provides shared utilities for middleware.\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{27/0c/6fb0419fc867627f4d0f9a5783b2e4a9c1b5098f8d5425919789157e0c6bdf05300e30890774cf7d6c13619eec3f58daf0bd895aceccd7addc93793708f1 → 18/81/57641a74d858c709af4b9e61756ad082814d0b61d68385a4bd4a46f27a10df8df808c95907e40318f11e496f925de7fc215203fd87066502ecf9bc5097ef}

@@ -544,7 +544,7 @@
   "dist-tags": {
     "latest": "2.0.0"
   },
-  "_rev": "2378-1184f61db4d6c482",
+  "_rev": "2379-cdc3c13b76a3e5c1",
   "_id": "color-name",
   "readme": "A JSON with color names and its values. Based on http://dev.w3.org/csswg/css-color/#named-colors.\n\n[![NPM](https://nodei.co/npm/color-name.png?mini=true)](https://nodei.co/npm/color-name/)\n\n\n```js\nimport colors from 'color-name';\ncolors.red //[255,0,0]\n```\n\n<a href=\"LICENSE\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/0/0c/MIT_logo.svg\" width=\"120\"/></a>",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{41/8e/bf09d963f9555ddd10f6aa4aab837415717303d9e30f57dc256d85245005a1f29d4e927f274e4f4f637679e74a55c76e6fdd2ddaa731311bf5ffc8a29eb1 → 18/fe/46902159e3865964b18d2ea79c91b4e15e51f20d6e37a2fdbe16f46fd78452a3683054e79632321564cde5d1dc6789f6f87778e80ff8495ed0895087d5bc}

@@ -372,7 +372,7 @@
   "dist-tags": {
     "latest": "2.0.4"
   },
-  "_rev": "2450-05e5a9f52746e2ee",
+  "_rev": "2452-d1bca02584b50729",
   "_id": "inherits",
   "readme": "Browser-friendly inheritance fully compatible with standard node.js\n[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).\n\nThis package exports standard `inherits` from node.js `util` module in\nnode environment, but also provides alternative browser-friendly\nimplementation through [browser\nfield](https://gist.github.com/shtylman/4339901). Alternative\nimplementation is a literal copy of standard one located in standalone\nmodule to avoid requiring of `util`. It also has a shim for old\nbrowsers with no `Object.create` support.\n\nWhile keeping you sure you are using standard `inherits`\nimplementation in node.js environment, it allows bundlers such as\n[browserify](https://github.com/substack/node-browserify) to not\ninclude full `util` package to your client code if all you need is\njust `inherits` function. It worth, because browser shim for `util`\npackage is large and `inherits` is often the single function you need\nfrom it.\n\nIt's recommended to use this package instead of\n`require('util').inherits` for any code that has chances to be used\nnot only in node.js but in browser too.\n\n## usage\n\n```js\nvar inherits = require('inherits');\n// then use exactly as the standard one\n```\n\n## note on version ~1.0\n\nVersion ~1.0 had completely different motivation and is not compatible\nneither with 2.0 nor with standard node.js `inherits`.\n\nIf you are using version ~1.0 and planning to switch to ~2.0, be\ncareful:\n\n* new version uses `super_` instead of `super` for referencing\n  superclass\n* new version overwrites current prototype while old one preserves any\n  existing fields on it",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{5d/9f/9181f314628fa1b0730718e7dbe383120b5dea91aac4ca7a53e760a4dd0aa83e20463d22e2caba6e48fa3c171b8367c37e8d94d46fc24147f54c41dc28c6 → 1a/37/cf1907e2d4842eb5e2f3cb6ae2458419d2430a0817b343f5430f9d53947daa1824af3e6639810b4caaf1e0c96e1d6887798cb30c729b05545d4ea3fb9dc7}

@@ -2196,7 +2196,7 @@
     "latest": "7.2.0",
     "version4": "4.2.3"
   },
-  "_rev": "2064-eee6ea74e416eeaf",
+  "_rev": "2065-d65cc75196471107",
   "_id": "string-width",
   "readme": "# string-width\n\n> Get the visual width of a string - the number of columns required to display it\n\nSome Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.\n\nUseful to be able to measure the actual width of command-line output.\n\n## Install\n\n```sh\nnpm install string-width\n```\n\n## Usage\n\n```js\nimport stringWidth from 'string-width';\n\nstringWidth('a');\n//=> 1\n\nstringWidth('古');\n//=> 2\n\nstringWidth('\\u001B[1m古\\u001B[22m');\n//=> 2\n```\n\n## API\n\n### stringWidth(string, options?)\n\n#### string\n\nType: `string`\n\nThe string to be counted.\n\n#### options\n\nType: `object`\n\n##### ambiguousIsNarrow\n\nType: `boolean`\\\nDefault: `true`\n\nCount [ambiguous width characters](https://www.unicode.org/reports/tr11/#Ambiguous) as having narrow width (count of 1) instead of wide width (count of 2).\n\n> Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). **If the context cannot be established reliably, they should be treated as narrow characters by default.**\n> - http://www.unicode.org/reports/tr11/\n\n##### countAnsiEscapeCodes\n\nType: `boolean`\\\nDefault: `false`\n\nWhether [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) should be counted.\n\n## Related\n\n- [string-width-cli](https://github.com/sindresorhus/string-width-cli) - CLI for this module\n- [string-length](https://github.com/sindresorhus/string-length) - Get the real length of a string\n- [widest-line](https://github.com/sindresorhus/widest-line) - Get the visual width of the widest line in a string\n- [get-east-asian-width](https://github.com/sindresorhus/get-east-asian-width) - Determine the East Asian Width of a Unicode character",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{82/8e/525e5a96a82e55f5a8332a24506eebbec5ebb85f239eb630f98f5d650119232caae1cf0360d4fee1f742c56b461347c71b1f4a647523e1df7f4cc863c5fb → 1b/77/14a492f7e6b14b06ede6c28a3fb7935dcc89829a37f8840f37262dd464bed479116c538b700809451cb839129936630a6d74e3c04c534c631ae0918c55ed}

@@ -5235,7 +5235,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "84-f752ce1db4141438",
+  "_rev": "85-3c79e288ec32d5c7",
   "_id": "@aws-sdk/util-hex-encoding",
   "readme": "# @aws-sdk/util-hex-encoding\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-hex-encoding/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-hex-encoding)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-hex-encoding.svg)](https://www.npmjs.com/package/@aws-sdk/util-hex-encoding)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0a/38/bb6de93cdf085c1a0a63fdd2b8222345daf0a4543f1db4d5f6579ad5eabe76260358458c227a69dc51ea2ca0e809460454115f73adbed53cc6b67477e594 → 1c/a5/b2b72b8d04ebf1ddc89c73cb8cec2886fc9276759011be01b1ba54a9539bddde21d62cc3e93b0dbb67df8aa42e72084d39ad92c46a93ecd3b3f82351a847}

@@ -5282,7 +5282,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "84-a4df747a9384ee89",
+  "_rev": "85-86efad46f6f322b5",
   "_id": "@aws-sdk/util-uri-escape",
   "readme": "# @aws-sdk/util-uri-escape\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/util-uri-escape/latest.svg)](https://www.npmjs.com/package/@aws-sdk/util-uri-escape)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/util-uri-escape.svg)](https://www.npmjs.com/package/@aws-sdk/util-uri-escape)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{a2/91/1b864abeff33c1bff94787cdae8db4f41ec1ec038a7c6538cc7db7505ce8be1b2958004ee1efda801cecbaa94d1d0b7c1bfd50faf74e474d8058d8de6812 → 1c/a8/3a49de9df47f46524f7a819ed95cbc984ff40992eae1f03352848b871730d01331544b48c79547074f58bb87ae328e921d7bde7e32389bca6e4196de0c07}

@@ -271,7 +271,7 @@
   "dist-tags": {
     "latest": "4.0.0"
   },
-  "_rev": "1339-1817b0800e9648ca",
+  "_rev": "1340-d7f83c31151a68e3",
   "_id": "shebang-regex",
   "readme": "# shebang-regex\n\n> Regular expression for matching a [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) line\n\n## Install\n\n```\n$ npm install shebang-regex\n```\n\n## Usage\n\n```js\nimport shebangRegex from 'shebang-regex';\n\nconst string = '#!/usr/bin/env node\\nconsole.log(\"unicorns\");';\n\nshebangRegex.test(string);\n//=> true\n\nshebangRegex.exec(string)[0];\n//=> '#!/usr/bin/env node'\n\nshebangRegex.exec(string)[1];\n//=> '/usr/bin/env node'\n```\n\n---\n\n<div align=\"center\">\n\t<b>\n\t\t<a href=\"https://tidelift.com/subscription/pkg/npm-shebang-regex?utm_source=npm-shebang-regex&utm_medium=referral&utm_campaign=readme\">Get professional support for this package with a Tidelift subscription</a>\n\t</b>\n\t<br>\n\t<sub>\n\t\tTidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.\n\t</sub>\n</div>",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{4b/e4/1325032a4f643f7c85ffbb1fd2bcb7ded4ebc71db02186099deafa4b39b9987d0803f1df531bf7a6a15b749e323a46400cb42dfcda8b2d289416072231fe → 1c/c8/93250fdc152a381930f4207f4f16994613177f5ea7245f4a6f3b4ffb4aeb33756d612bf2b54ed0ad51bb77c10a068d2f098fb3eca68494dc19bca8b3ba37}

@@ -2670,7 +2670,7 @@
     "latest": "6.0.2",
     "next": "5.0.0-beta.0"
   },
-  "_rev": "201-f546a291160d0099",
+  "_rev": "202-47313441179c1e83",
   "_id": "event-target-shim",
   "readme": "# event-target-shim\n\n[![npm version](https://img.shields.io/npm/v/event-target-shim.svg)](https://www.npmjs.com/package/event-target-shim)\n[![Downloads/month](https://img.shields.io/npm/dm/event-target-shim.svg)](http://www.npmtrends.com/event-target-shim)\n[![Build Status](https://github.com/mysticatea/event-target-shim/workflows/CI/badge.svg)](https://github.com/mysticatea/event-target-shim/actions)\n[![Coverage Status](https://codecov.io/gh/mysticatea/event-target-shim/branch/master/graph/badge.svg)](https://codecov.io/gh/mysticatea/event-target-shim)\n[![Dependency Status](https://david-dm.org/mysticatea/event-target-shim.svg)](https://david-dm.org/mysticatea/event-target-shim)\n\nAn implementation of [WHATWG `EventTarget` interface](https://dom.spec.whatwg.org/#interface-eventtarget) and [WHATWG `Event` interface](https://dom.spec.whatwg.org/#interface-event). This implementation supports constructor, `passive`, `once`, and `signal`.\n\nThis implementation is designed ...\n\n- Working fine on both browsers and Node.js.\n- TypeScript friendly.\n\n## 💿 Installation\n\nUse [npm](https://www.npmjs.com/) or a compatible tool.\n\n```\nnpm install event-target-shim\n```\n\n## 📖 Getting started\n\n```js\nimport { EventTarget, Event } from \"event-target-shim\";\n\n// constructor (was added to the standard on 8 Jul 2017)\nconst myNode = new EventTarget();\n\n// passive flag (was added to the standard on 6 Jan 2016)\nmyNode.addEventListener(\n  \"hello\",\n  (e) => {\n    e.preventDefault(); // ignored and print warning on console.\n  },\n  { passive: true }\n);\n\n// once flag (was added to the standard on 15 Apr 2016)\nmyNode.addEventListener(\"hello\", listener, { once: true });\nmyNode.dispatchEvent(new Event(\"hello\")); // remove the listener after call.\n\n// signal (was added to the standard on 4 Dec 2020)\nconst ac = new AbortController();\nmyNode.addEventListener(\"hello\", listener, { signal: ac.signal });\nac.abort(); // remove the listener.\n```\n\n- For browsers, use a bundler such as [Webpack](https://webpack.js.org/) to bundle.\n  - If you want to support IE11, use `import {} from \"event-target-shim/es5\"` instead. It's a transpiled code by babel. It depends on `@baebl/runtime` (`^7.12.0`) package.\n- The `AbortController` class was added to the standard on 14 Jul 2017. If you want the shim of that, use [abort-controller](https://www.npmjs.com/package/abort-controller) package.\n\n## 📚 API Reference\n\nSee [docs/reference.md](docs/reference.md).\n\n## 💥 Migrating to v6\n\nSee [docs/migrating-to-v6.md](docs/migrating-to-v6.md).\n\n## 📰 Changelog\n\nSee [GitHub releases](https://github.com/mysticatea/event-target-shim/releases).\n\n## 🍻 Contributing\n\nContributing is welcome ❤️\n\nPlease use GitHub issues/PRs.\n\n### Development tools\n\n- `npm install` installs dependencies for development.\n- `npm test` runs tests and measures code coverage.\n- `npm run watch:mocha` runs tests on each file change.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{f2/31/b0fcab965e29568ea65d4b63e67ba540ffdf6ba5b8bb0fb2d70bce1f638029e68c163a44026b84e0aaaaa1aefde5acf54c92d9ae4ec806d79731387cdf72 → 1d/7d/355689c0b69bccd885f8b165239b2e81b0f91cec5a64c0cb991fb9f04374a877bb1b81268225debb0fdfe0c37e19ebc7110e70d6fbc51aa15ff8a398f994}

@@ -535509,7 +535509,7 @@
     "tag-for-publishing-older-releases": "4.1.6",
     "dev": "3.9.4"
   },
-  "_rev": "1653-bd75edcebd2a5243",
+  "_rev": "1654-3225e704d5fd3af8",
   "_id": "typescript",
   "readme": "",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/1e/{74/e72345133cef3d4d86f2dba85548bcfd41cad11029fc4acb77cd8450e42b678ef15d2d4a0747b40cfd6aa1d3e40811bc349d5a953961982968f98c8a552c → 29/6708da187eb750df16be061570b9733d9a653930355cd1e9e9153a1c1029362d70e553dccc5efbc510246ad90b5809ba27f7bda97f97b0e2f7d9ca70dbf9}

@@ -15027,7 +15027,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "88-1d4661235c6ffa33",
+  "_rev": "89-b07cfa84863a338c",
   "_id": "@aws-sdk/credential-provider-imds",
   "readme": "# @aws-sdk/credential-provider-imds\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/credential-provider-imds/latest.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-imds)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/credential-provider-imds.svg)](https://www.npmjs.com/package/@aws-sdk/credential-provider-imds)\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/{52/04/8c80b3babd621f274c26b52fde15e781532a80a8757f6fea8f9b340cbf0a4a1f9abd166c7aa0cf89f6d7768b54c5e9811df084b6d5af03c9f8bc525bd9a6 → 21/91/bbf460357f73a2c328a5d3b693c5873834be937eebdf998b7b87b1082630948dc27ff1a091c21a478fab31385e0a7499aa7a68229803e27b6ce513f097f1}

@@ -636,7 +636,7 @@
   "dist-tags": {
     "latest": "2.0.5"
   },
-  "_rev": "1577-cddc1b59068956b6",
+  "_rev": "1578-134d1957cbcede03",
   "_id": "isarray",
   "readme": "# isarray\n\n`Array#isArray` for older browsers and deprecated Node.js versions.\n\n[![build status](https://secure.travis-ci.org/juliangruber/isarray.svg)](http://travis-ci.org/juliangruber/isarray)\n[![downloads](https://img.shields.io/npm/dm/isarray.svg)](https://www.npmjs.org/package/isarray)\n\n[![browser support](https://ci.testling.com/juliangruber/isarray.png)\n](https://ci.testling.com/juliangruber/isarray)\n\n__Just use Array.isArray directly__, unless you need to support those older versions.\n\n## Usage\n\n```js\nvar isArray = require('isarray');\n\nconsole.log(isArray([])); // => true\nconsole.log(isArray({})); // => false\n```\n\n## Installation\n\nWith [npm](https://npmjs.org) do\n\n```bash\n$ npm install isarray\n```\n\nThen bundle for the browser with\n[browserify](https://github.com/substack/node-browserify).\n\n## Sponsors\n\nThis module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!\n\nDo you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{9b/0c/93bcf2fed76a59e333ce94959bfe75a291d395ee4ce7d63d22a89c8ac106082ad656d5d9bd82a416fbeea68fd95db434b7605a0236d85ca2d2471aeae72c → 23/e9/c8930174e9934a6ec323c11dedbc805d38ba458257255ad6f322e67e238503f24e613f87b903949aaa2bf5d1e83778d99cea47d545a66df567b253d88f97}

@@ -2078,7 +2078,7 @@
   "dist-tags": {
     "latest": "3.3.1"
   },
-  "_rev": "558-2c3274249e2f7aa6",
+  "_rev": "559-d1df1ad93f7fba71",
   "_id": "foreground-child",
   "readme": "# foreground-child\n\nRun a child as if it's the foreground process. Give it stdio. Exit\nwhen it exits.\n\nMostly this module is here to support some use cases around\nwrapping child processes for test coverage and such. But it's\nalso generally useful any time you want one program to execute\nanother as if it's the \"main\" process, for example, if a program\ntakes a `--cmd` argument to execute in some way.\n\n## USAGE\n\n```js\nimport { foregroundChild } from 'foreground-child'\n// hybrid module, this also works:\n// const { foregroundChild } = require('foreground-child')\n\n// cats out this file\nconst child = foregroundChild('cat', [__filename])\n\n// At this point, it's best to just do nothing else.\n// return or whatever.\n// If the child gets a signal, or just exits, then this\n// parent process will exit in the same way.\n```\n\nYou can provide custom spawn options by passing an object after\nthe program and arguments:\n\n```js\nconst child = foregroundChild(`cat ${__filename}`, { shell: true })\n```\n\nA callback can optionally be provided, if you want to perform an\naction before your foreground-child exits:\n\n```js\nconst child = foregroundChild('cat', [__filename], spawnOptions, () => {\n  doSomeActions()\n})\n```\n\nThe callback can return a Promise in order to perform\nasynchronous actions. If the callback does not return a promise,\nthen it must complete its actions within a single JavaScript\ntick.\n\n```js\nconst child = foregroundChild('cat', [__filename], async () => {\n  await doSomeAsyncActions()\n})\n```\n\nIf the callback throws or rejects, then it will be unhandled, and\nnode will exit in error.\n\nIf the callback returns a string value, then that will be used as\nthe signal to exit the parent process. If it returns a number,\nthen that number will be used as the parent exit status code. If\nit returns boolean `false`, then the parent process will not be\nterminated. If it returns `undefined`, then it will exit with the\nsame signal/code as the child process.\n\n## Caveats\n\nThe \"normal\" standard IO file descriptors (0, 1, and 2 for stdin,\nstdout, and stderr respectively) are shared with the child process.\nAdditionally, if there is an IPC channel set up in the parent, then\nmessages are proxied to the child on file descriptor 3.\n\nIn Node, it's possible to also map arbitrary file descriptors\ninto a child process. In these cases, foreground-child will not\nmap the file descriptors into the child. If file descriptors 0,\n1, or 2 are used for the IPC channel, then strange behavior may\nhappen (like printing IPC messages to stderr, for example).\n\nNote that a SIGKILL will always kill the parent process, but\nwill not proxy the signal to the child process, because SIGKILL\ncannot be caught. In order to address this, a special \"watchdog\"\nchild process is spawned which will send a SIGKILL to the child\nprocess if it does not terminate within half a second after the\nwatchdog receives a SIGHUP due to its parent terminating.\n\nOn Windows, issuing a `process.kill(process.pid, signal)` with a\nfatal termination signal may cause the process to exit with a `1`\nstatus code rather than reporting the signal properly. This\nmodule tries to do the right thing, but on Windows systems, you\nmay see that incorrect result. There is as far as I'm aware no\nworkaround for this.\n\n## util: `foreground-child/proxy-signals`\n\nIf you just want to proxy the signals to a child process that the\nmain process receives, you can use the `proxy-signals` export\nfrom this package.\n\n```js\nimport { proxySignals } from 'foreground-child/proxy-signals'\n\nconst childProcess = spawn('command', ['some', 'args'])\nproxySignals(childProcess)\n```\n\nNow, any fatal signal received by the current process will be\nproxied to the child process.\n\nIt doesn't go in the other direction; ie, signals sent to the\nchild process will not affect the parent. For that, listen to the\nchild `exit` or `close` events, and handle them appropriately.\n\n## util: `foreground-child/watchdog`\n\nIf you are spawning a child process, and want to ensure that it\nisn't left dangling if the parent process exits, you can use the\nwatchdog utility exported by this module.\n\n```js\nimport { watchdog } from 'foreground-child/watchdog'\n\nconst childProcess = spawn('command', ['some', 'args'])\nconst watchdogProcess = watchdog(childProcess)\n\n// watchdogProcess is a reference to the process monitoring the\n// parent and child. There's usually no reason to do anything\n// with it, as it's silent and will terminate\n// automatically when it's no longer needed.\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{41/91/f3e0fa3b7d22efa19431cf2be337076f1d84741323684550c5ed3f3591b42b50a4498be623c59d51e5fcaa7a5d4492dfdab8aac15f42db0185cd915387a5 → 24/de/69fdb105d4f01c7a37d42ec9e733a0525c3dddcbc5730aa97d3274043061c75acd87a48d525da37d25da14c33ab3d7aa5856a264f828c4c4eb08c842bde8}

@@ -232,7 +232,7 @@
   "dist-tags": {
     "latest": "2.0.0"
   },
-  "_rev": "1710-cd596da48c3ccc44",
+  "_rev": "1711-e0c1cfdeb5b37f8c",
   "_id": "path-is-absolute",
   "readme": "# Deprecated\n\nThis package is no longer relevant as Node.js 0.12 is unmaintained.\n\n---\n\n# path-is-absolute [![Build Status](https://travis-ci.org/sindresorhus/path-is-absolute.svg?branch=master)](https://travis-ci.org/sindresorhus/path-is-absolute)\n\n> Node.js 0.12 [`path.isAbsolute()`](http://nodejs.org/api/path.html#path_path_isabsolute_path) [ponyfill](https://ponyfill.com)\n\n\n## Install\n\n```\n$ npm install --save path-is-absolute\n```\n\n\n## Usage\n\n```js\nconst pathIsAbsolute = require('path-is-absolute');\n\n// Running on Linux\npathIsAbsolute('/home/foo');\n//=> true\npathIsAbsolute('C:/Users/foo');\n//=> false\n\n// Running on Windows\npathIsAbsolute('C:/Users/foo');\n//=> true\npathIsAbsolute('/home/foo');\n//=> false\n\n// Running on any OS\npathIsAbsolute.posix('/home/foo');\n//=> true\npathIsAbsolute.posix('C:/Users/foo');\n//=> false\npathIsAbsolute.win32('C:/Users/foo');\n//=> true\npathIsAbsolute.win32('/home/foo');\n//=> false\n```\n\n\n## API\n\nSee the [`path.isAbsolute()` docs](http://nodejs.org/api/path.html#path_path_isabsolute_path).\n\n### pathIsAbsolute(path)\n\n### pathIsAbsolute.posix(path)\n\nPOSIX specific version.\n\n### pathIsAbsolute.win32(path)\n\nWindows specific version.\n\n\n## License\n\nMIT © [Sindre Sorhus](https://sindresorhus.com)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{67/91/7cb4e695360e1080d32bfbbbfbf68d2b7d7407a88d819bf66cf4be9a4dd61edc82ca5eb43dd6bc3c534343ffd980045d058d156791934a7b3e8e223626ae → 25/34/dd553b9252303ff78678f8b2ab4b7be3c003a69bddadb93c647deeed80dcc4043885ceda7a17db08cda549be4c548b8740972159f23b6116b2f22cf750e1}

@@ -226,7 +226,7 @@
   "dist-tags": {
     "latest": "1.0.1"
   },
-  "_rev": "89-4eac6063efe2cef0",
+  "_rev": "90-5f5a5cdb39a24857",
   "_id": "package-json-from-dist",
   "readme": "# package-json-from-dist\n\nSometimes you want to load the `package.json` into your\nTypeScript program, and it's tempting to just `import\n'../package.json'`, since that seems to work.\n\nHowever, this requires `tsc` to make an entire copy of your\n`package.json` file into the `dist` folder, which is a problem if\nyou're using something like\n[tshy](https://github.com/isaacs/tshy), which uses the\n`package.json` file in dist for another purpose. Even when that\ndoes work, it's asking the module system to do a bunch of extra\nfs system calls, just to load a version number or something. (See\n[this issue](https://github.com/isaacs/tshy/issues/61).)\n\nThis module helps by just finding the package.json file\nappropriately, and reading and parsing it in the most normal\nfashion.\n\n## Caveats\n\nThis _only_ works if your code builds into a target folder called\n`dist`, which is in the root of the package. It also requires\nthat you do not have a folder named `node_modules` anywhere\nwithin your dev environment, or else it'll get the wrong answers\nthere. (But, at least, that'll be in dev, so you're pretty likely\nto notice.)\n\nIf you build to some other location, then you'll need a different\napproach. (Feel free to fork this module and make it your own, or\njust put the code right inline, there's not much of it.)\n\n## USAGE\n\n```js\n// src/index.ts\nimport {\n  findPackageJson,\n  loadPackageJson,\n} from 'package-json-from-dist'\n\nconst pj = findPackageJson(import.meta.url)\nconsole.log(`package.json found at ${pj}`)\n\nconst pkg = loadPackageJson(import.meta.url)\nconsole.log(`Hello from ${pkg.name}@${pkg.version}`)\n```\n\nIf your module is not directly in the `./src` folder, then you need\nto specify the path that you would expect to find the\n`package.json` when it's _not_ built to the `dist` folder.\n\n```js\n// src/components/something.ts\nimport {\n  findPackageJson,\n  loadPackageJson,\n} from 'package-json-from-dist'\n\nconst pj = findPackageJson(import.meta.url, '../../package.json')\nconsole.log(`package.json found at ${pj}`)\n\nconst pkg = loadPackageJson(import.meta.url, '../../package.json')\nconsole.log(`Hello from ${pkg.name}@${pkg.version}`)\n```\n\nWhen running from CommmonJS, use `__filename` instead of\n`import.meta.url`.\n\n```js\n// src/index.cts\nimport {\n  findPackageJson,\n  loadPackageJson,\n} from 'package-json-from-dist'\n\nconst pj = findPackageJson(__filename)\nconsole.log(`package.json found at ${pj}`)\n\nconst pkg = loadPackageJson(__filename)\nconsole.log(`Hello from ${pkg.name}@${pkg.version}`)\n```\n\nSince [tshy](https://github.com/isaacs/tshy) builds _both_\nCommonJS and ESM by default, you may find that you need a\nCommonJS override and some `//@ts-ignore` magic to make it work.\n\n`src/pkg.ts`:\n\n```js\nimport {\n  findPackageJson,\n  loadPackageJson,\n} from 'package-json-from-dist'\n//@ts-ignore\nexport const pkg = loadPackageJson(import.meta.url)\n//@ts-ignore\nexport const pj = findPackageJson(import.meta.url)\n```\n\n`src/pkg-cjs.cts`:\n\n```js\nimport {\n  findPackageJson,\n  loadPackageJson,\n} from 'package-json-from-dist'\nexport const pkg = loadPackageJson(__filename)\nexport const pj = findPackageJson(__filename)\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{07/6e/a65c213dab362ed0ce8df890d6720495924759a3a4d48378aff4697cc67084e89f4c7d0353358bf2307c0163a2311beb690187e79374f19460f39e40b20f → 29/88/3cbe34ce6b46b298b6d6dd46ab5bfbb59152ae101c8c7a9a168506077fdf58370a92f9e1efb04605c200e0dbc675ebccce4ee929dbd9519c0b941379b1ae}

@@ -11292,7 +11292,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "91-318627413eb0d06b",
+  "_rev": "92-5467cadb56d49ecc",
   "_id": "@aws-sdk/service-error-classification",
   "readme": "# @aws-sdk/service-error-classification\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/service-error-classification/latest.svg)](https://www.npmjs.com/package/@aws-sdk/service-error-classification)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/service-error-classification.svg)](https://www.npmjs.com/package/@aws-sdk/service-error-classification)",
   "_attachments": {}