mrs-toolbox-cli 6.0.8 → 6.0.10-42e27b2-develop

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>","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAW+BA,CAACC,IAADD,EAAA;A,2BAAiB,I;IAAQ,4BAA0C,IAA1C,C;EAAzB,C;;;;2CAKaE,CAAAC,U,EAAAC,WAAAF,EAAC;A;;;;EAAD,C;2CAhB5C,E,EAAAE,W;;;0CAgB4CC,CAAAA,EAAA;A;;MAAA,I;;;;;;;;;;;;;EAAC,C;4CAAD,U,EAsEzC,U;;;;;6BAtEyCC,C,kBAAAA,E;;qBAAAC,CAAAJ,U,EAAAC,WAAAG,E;;K;;;G;eAD5CP,CAAAA,EAAA;A,IAAa,2B;EAAb,C;+BACIQ,CAAAA,EAAmC;A,IAAO,OAAP,KAAK,wBAAL,C;EAAM,C;kCAQzC,M;;;;iDAAwCN,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EAA+B,C;iDAzBvC,E,EAAAE,W;;;gDAwB4CC,CAAAA,EAAA;A;;MAAA,I;;;;UACpB,sCAAM,gB;UAC1B,oB;;;;;;;;;EAAA,C;kDAFwC,U,EA8DzC,U;;;;;mCA9DyCI,CAAxC,M,oBAAwCA,E;;qBAAAC,CAAAP,U,EAAAC,WAAAM,E;;K;;;G;qBAL5CV,CAAAA,EAAA;A,IAAmB,4BAAwB,YAAxB,C;IAGG,2D;EAHtB,C;qCACIW,CAAkBC,OAAlBD,EAAsC;A,IAAuB,OAAvB,uB;EAAsB,C;qCAE1CE,CAAAA,EAAA;A,IAAA,kD;EAAS,C;qCAE3BL,CAAAA,EAAmC;A,IAElC,OAFkC,KAAK,oCAAL,C;EAEnC,C;;;;mDAQyCN,CAAAY,E,EAAAV,WAAAF,EAAC;A;;;;EAAD,C;mDAlC7C,E,EAAAE,W;;;kDAkC6CC,CAAAA,EAAA;A;;MAAA,I;;;;;;;;;;;;;EAAC,C;oDAAD,E,EAoD1C,U;;;;;qCApD0CU,C,kBAAAA,E;;qBAAAC,CAAAF,E,EAAAV,WAAAY,E;;K;;;G;sDAAAhB,C,UAAAA,EAAA;A,IAAA,uB;EAAA,C;sEAAAiB,CALrBC,K,EAKqBd,WAAAa,E;;G;;;;yEAlC7CE,C,KAAAA,E;;;;;;;;;;;;;;G;2EAAAC,CAAAA,E;;G;4BAiCI,M;;;;2CAAwClB,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EAAsC,C;2CAlC9C,E,EAAAE,W;;;0CAiC4CC,CAAAA,EAAA;A;;MAAA,I;;;;;;4BACpB,kCAAK,gBAAL,O;;;;;;;;;gBAAqB,wC;4BAAR,eAAQ,sDAAR,O;;;;;;;YACjC,oB;;;;;;;;;;;;;;EAAA,C;4CAFwC,U,EAqDzC,U;;;;;6BArDyCgB,CAAxC,M,oBAAwCA,E;;qBAAAC,CAAAnB,U,EAAAC,WAAAkB,E;;K;;;G;eAJ5CtB,CAAAA,EAAA;A,IAAa,4BAAwB,MAAxB,C;IAEK,0BAAO,OAAM,UAAN,CAAP,EAAgC,kBAAhC,6B;EAFlB,C;+BACIW,CAAkBC,OAAlBD,EAAsC;A,IAAY,OAAZ,Y;EAAW,C;+BACnCY,CAAAA,EAAA;A,IAAA,8C;EAAkD,C;+BAEhEf,CAAAA,EAAmC;A,IAElC,OAFkC,KAAK,8BAAL,C;EAEnC,C;+BAOA,M;;;;8CAAwCN,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EAA8B,C;8CA3CtC,E,EAAAE,W;;;6CA0C4CC,CAAAA,EAAA;A;;MAAA,I;;;;UACpB,kCAAQ,gBAAR,C;UACpB,oB;;;;;;;;;EAAA,C;+CAFwC,U,EA4CzC,U;;;;;gCA5CyCmB,CAAxC,M,oBAAwCA,E;;qBAAAC,CAAAtB,U,EAAAC,WAAAqB,E;;K;;;G;kBAJ5CzB,CAAAA,EAAA;A,IAAgB,4BAAwB,SAAxB,C;IAEE,0BAAO,OAAM,UAAN,CAAP,EAAgC,kBAAhC,+B;EAFlB,C;kCACIW,CAAkBC,OAAlBD,EAAsC;A,IAAmB,OAAnB,mB;EAAkB,C;kCAC1CY,CAAAA,EAAA;A,IAAA,8C;EAAkD,C;kCAEhEf,CAAAA,EAAmC;A,IAElC,OAFkC,KAAK,iCAAL,C;EAEnC,C;;;;qDAUiBN,CAAAY,E,EAAAV,WAAAF,EAAC;A;;;;EAAD,C;qDAtDrB,E,EAAAE,W;;;oDAsDqBC,CAAAA,EAAA;A;;MAAA,I;;;;;;;;;;;;;EAAC,C;sDAAD,E,EAgClB,U;;;;;uCAhCkBqB,C,kBAAAA,E;;qBAAAC,CAAAb,E,EAAAV,WAAAuB,E;;K;;;G;wDAAA3B,C,UAAAA,EAAA;A,IAAA,uB;EAAA,C;wEAAAiB,CAzBGC,K,EAyBHd,WAAAa,E;;G;;;;2EAtDrBE,C,KAAAA,E;;;;;;;;;;;;;;G;6EAAAC,CAAAA,E;;G;8BAoDI,M;;;;6CAAwClB,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EACc,C;6CAtDtB,E,EAAAE,W;;;4CAoD4CC,CAAAA,EAAA;A;;MAAA,I;;;;;;;gBACG,iC;4BAAZ,UAAY,yBAAW,OAAX,iBAAZ,a;;;;;;;YAA3B,0B;;gBACa,0C;4BAAR,KAAL,KAAK,KAAQ,wDAAR,O;;;;;;;YACT,oB;;;;;;;;;;;;;;EAAA,C;8CAHwC,U,EAkCzC,U;;;;;+BAlCyCuB,CAAxC,M,oBAAwCA,E;;qBAAAC,CAAA1B,U,EAAAC,WAAAyB,E;;K;;;G;iBAL5C7B,CAAAA,EAAA;A,IAAe,4BAAwB,QAAxB,C;IAGI,0BAAO,OAAM,WAAN,CAAP,EAAiC,uBAAjC,8B;EAHnB,C;iCACIW,CAAkBC,OAAlBD,EAAsC;A,IAA6B,OAA7B,6B;EAA4B,C;iCAEnDmB,CAAAA,EAAA;A,IAAA,+C;EAAwD,C;iCAEvEtB,CAAAA,EAAmC;A,IAGlC,OAHkC,KAAK,gCAAL,C;EAGnC,C;;;;qDAUiBN,CAAAY,E,EAAAV,WAAAF,EAAC;A;;;;EAAD,C;qDAjErB,E,EAAAE,W;;;oDAiEqBC,CAAAA,EAAA;A;;MAAA,I;;;;;;;;;;;;;EAAC,C;sDAAD,E,EAqBlB,U;;;;;uCArBkB0B,C,kBAAAA,E;;qBAAAC,CAAAlB,E,EAAAV,WAAA4B,E;;K;;;G;wDAAAhC,C,UAAAA,EAAA;A,IAAA,uB;EAAA,C;wEAAAiB,CApCGC,K,EAoCHd,WAAAa,E;;G;;;;2EAjErBE,C,KAAAA,E;;;;;;;;;;;;;;G;6EAAAC,CAAAA,E;;G;8BA+DI,M;;;;6CAAwClB,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EACc,C;6CAjEtB,E,EAAAE,W;;;4CA+D4CC,CAAAA,EAAA;A;;MAAA,I;;;;;YACpC,aAA2B,kCAAY,gBAAZ,C;;gBACd,0C;4BAAR,KAAL,KAAK,KAAQ,wDAAR,O;;;;;;;YACT,oB;;;;;;;;;;;;;;EAAA,C;8CAHwC,U,EAuBzC,U;;;;;+BAvByC4B,CAAxC,M,oBAAwCA,E;;qBAAAC,CAAA/B,U,EAAAC,WAAA8B,E;;K;;;G;iBAL5ClC,CAAAA,EAAA;A,IAAe,4BAAwB,QAAxB,C;IAGW,0BAAO,OAAM,UAAN,CAAP,EAAgC,yBAAhC,qC;EAH1B,C;iCACIW,CAAkBC,OAAlBD,EAAsC;A,IAAqB,OAArB,qB;EAAoB,C;iCAEpCwB,CAAAA,EAAA;A,IAAA,sD;EAAyD,C;iCAE/E3B,CAAAA,EAAmC;A,IAGlC,OAHkC,KAAK,gCAAL,C;EAGnC,C;;;;8CAMwCN,CAAAC,U,EAAAC,WAAAF,EAAG;A;;;;EAAuB,C;8CAxEtE,E,EAAAE,W;;;6CAwE4CC,CAAAA,EAAA;A;;MAAA,I;;;;;;4BAAG,eAAK,kBAAL,O;;;;;;;YAAyB,oB;;;;;;;;;;;;;;EAAA,C;+CAA5B,U,EAczC,U;;;;;gCAdyC+B,C,kBAAAA,E;;qBAAAC,CAAAlC,U,EAAAC,WAAAiC,E;;K;;;G;kBAH5CrC,CAAAA,EAAA;A,IAAgB,4BAAwB,SAAxB,C;EAAhB,C;kCACIW,CAAkBC,OAAlBD,EAAsC;A,IAAqB,OAArB,qB;EAAoB,C;kCAE1DH,CAAAA,EAAmC;A,IAAkC,OAAlC,KAAK,2BAAL,C;EAAiC,C;;;;8CAO5BN,CAAAC,U,EAAAC,WAAAF,EACpC;A;;;;EAAgC,C;8CAhFxC,E,EAAAE,W;;;6CA+E4CC,CAAAA,EAAA;A;;MAAA,I;;;;;;4BACpB,mCAAU,S;;;;;;;YAC9B,oB;;;;;;;;;;;;;;EAAA,C;+CAFwC,U,EAOzC,U;;;;;gCAPyCiC,C,kBAAAA,E;;qBAAAC,CAAApC,U,EAAAC,WAAAmC,E;;K;;;G;kBAJ5CvC,CAAAA,EAAA;A,IAAgB,4BAAwB,SAAxB,C;EAAhB,C;kCAEIW,CAAkBC,OAAlBD,EAAsC;A,IAA+B,OAA/B,+B;EAA8B,C;kCAEpEH,CAAAA,EAAmC;A,IAElC,OAFkC,KAAK,2BAAL,C;EAEnC,C;gBAGJgC,CAAIC,a,EAAuBC,IAA3BF,EAA8D;A;QAC1DG,QCiBoD,yB;;iBDhBX,OAAL,IAAK,C;QEZrCC,SAAa,+BFYa,aEZb,EAAe,MAAf,C;;yBACT,M,CAAO,K;eAcI,QAAf,cAAe,C;;;UC5DnBC,YAA4B,I;MAC5B,IAAI;A;YD4DuB,4B;eAAA,qB,EAAa;A,cAA3BC,aAAc,qB;;;wBACJ,UFL0C,CEK/B,KFL+B,M;UAAZ,KIrChD,GAAI,OAAJ,C;QF2CG,C;;MC5DR,C;iCAAuB;A,cAAdC,M;UACL,YAAY,C;UACZ,MAAM,C;QACV,C;;;;cAAU;A,QACD,mBAAa,SAAb,C;MACT,C;;IHkDA,OAAO,KAAK,4BAAL,C;EACX,C;eAEAC,CAAIP,a,EAAsBC,IAA1BM,EAA6D;A;;;MElCrD,IAAI;A;QACA,YFkC4C,MAAR,aAAQ,EAAM,IAAN,C;;MEjChD,C;sCAAwB;A,cAAfD,M;UFiC+B,aEhC5B,KAAkB,CAAlB,C;UFgC4B,aE/B5B,MAAe,OAAY,CAAZ,CAAc,KAAd,C;UACvB,MAAM,kBAAc,CAAd,CAAgB,KAAhB,C;QACV,C;;;;;IF6BJ,OAAyB,S;EAC7B,C;qBAIAE,CAAuBP,I,EAAvBtC,WAAA6C,EAA4C;A,QACxCC,UAAqB,YAAP,UAAO,EACjB,mBACA,UADA,EAEA,aAFA,EAGA,YAHA,EAIA,YAJA,EAKA,aALA,EAMA,aANA,EAOA,aAPA,CADiB,C;QAUrBC,aAAuC,KAAR,OAAQ,EAAK,IAAL,C;QACpB,yC;IAGvB,OAHI,UAAW,KAAQ,sDAAR,c;EAGf,C;wDAHuBnD,C,UAAAA,EAAA;A,IAAA,uB;EAAA,C;wEAAAiB,CA/ECC,K,EA+EDd,WAAAa,E;;G;;;;2EA5GvBE,C,KAAAA,E;;;;;;;;;;;;;;G;6EAAAC,CAAAA,E;;G;yBAqFIgC,M;;;;wCAEYlD,CAAAC,U,EAAAC,WAAAF,EAAE;A;;;;EAA4B,C;wCAvF9C,E,EAAAE,W;;;uCAuFgBC,CAAAA,EAAA;A;;MAAA,I;;;;;;+BAAE,K;;YAwBkszD,2B;;;;iBAAA,c;;;;;YAAX,aAAW,c;;+BAAa,K;;;4BAxB/rzD,yBAAQ,KAAR,O;;;;;;;;;;YAAc,oB;;;;;;;;;;;;;;EAAA,C;yCAAhC,U,EADb,U;;;;;0BACagD,CAFZD,M,oBAEYC,E;;qBAAAC,CAAAnD,U,EAAAC,WAAAkD,E;;K;;;G;8BAUZC,Q;;;;6CAWmBrD,CAAAY,E,EAAAV,WAAAF,EACf;A;;;;EAAe,C;6CA7GvB,E,EAAAE,W;;;4CA4GuBC,CAAAA,EAAA;A;;MAAA,I;;;;UACP,KAAR,KAAQ,UAAK,KAAL,C;UACZ,oB;;;;;;;;;EAAA,C;8CAFmB,E,EAtBpB,U;;;;;+BAsBoBmD,CAXnBD,Q,oBAWmBC,E;;qBAAAC,CAAA3C,E,EAAAV,WAAAqD,E;;K;;;G;6BAtFDC,CAAAA,E;kCAAA,Y,KAAA,U,WAAAC,CA+CLC,QA/CKD,E;;K,EAAA,I;G;+BAAAD,CAAAA,E;kCAAA,Y,KAAA,U,WAAAC,CA+CLC,QA/CKD,E;;K,EAAA,I;G;yBASJE,CAAAA,E;kCAAA,Q,KAAA,U,WAAAF,CAsCDC,QAtCCD,E;;K,EAAA,I;G;2BAAAE,CAAAA,E;kCAAA,Q,KAAA,U,WAAAF,CAsCDC,QAtCCD,E;;K,EAAA,I;G;2BASAE,CAAAA,E;kCAAA,Q,KAAA,U,WAAAF,CA6BDC,QA7BCD,E;;K,EAAA,I;G;2BAAAE,CAAAA,E;kCAAA,Q,KAAA,U,WAAAF,CA6BDC,QA7BCD,E;;K,EAAA,I;G;0BAUCG,CAAAA,E;kCAAA,S,KAAA,U,WAAAH,CAmBFC,QAnBED,E;;K,EAAA,I;G;4BAAAG,CAAAA,E;kCAAA,S,KAAA,U,WAAAH,CAmBFC,QAnBED,E;;K,EAAA,I;G;iCAWOI,CAAAA,E;kCAAA,gB,KAAA,U,WAAAJ,CAQTC,QARSD,E;;K,EAAA,I;G;mCAAAI,CAAAA,E;kCAAA,gB,KAAA,U,WAAAJ,CAQTC,QARSD,E;;K,EAAA,I;G;iBK3D1BX,CAAwBgB,I,EAAxB5D,WAAA4C,EAA6C;A,cAC9B,OAAa,CAAL,IAAK,OAAM,CAAN,C;QAAxBN,iDAAW,GAAXA,c;IAGJ,OADI,WAAW,IAAX,c;EACJ,C;;;;;;;;;;;;"}
+{"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/{6b/8e/2fc287af1461bf7f85c1b5983720699f1a9974d27e66e62c4c9ea15edc54caba1151ea53df2a3b9ac86c6f12f6855bfcc24eb4c0692937caded9f41c6d03 → 00/07/1acfc33ef022eeda82817e775aca960797e37577e2ed154c1e07be4edc789c253a77bb52d136fa8a47abfe36f1b18a7890316f11d23a349b9254e014cb44}

@@ -5910,7 +5910,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.8"
   },
-  "_rev": "126-c07f37bc4b1600d6",
+  "_rev": "132-4cb448000b632400",
   "_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/{9a/95/56bf3f9f7a120dc9b34c21461df320395afa7d64f19f132a3926dc358ec2618a4b0e7055a2a2ba68985dbc2a8a3015b0a31e306ec2b2bac3ce32ab67703a → 01/3f/32006554967d821671627acf092111eafb31ee2caf243ac79c08c9cb8800c87d77063f7b105cd4227a3e2130b09f26eda3d81ca17707ffd9dca0d439835c}

@@ -13869,7 +13869,7 @@
     "v7-legacy": "7.2.0",
     "legacy-v10": "10.4.5"
   },
-  "_rev": "2375-5d08eef132ee04f5",
+  "_rev": "2392-b73a3a58c6f80fce",
   "_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/{96/6c/ea6e7e1e2d573ced038562c28bb0a037c190e493be767ffe9dd905a2486e0516510ce0ba632f80d47fda6547530446c174ed3e56d61227eb738c8caed574 → 01/cd/6fb8a195edab5f468c7416166c93ec2c7a8ae2dd52d02ee5dc5c29b968f4c60b3e96cbf391ad87fbba9559b74b03e0e83b817bc23de12302f0a58d08c005}

@@ -16048,7 +16048,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "3.5.1-rc.0"
   },
-  "_rev": "94-b5e06588e3acde56",
+  "_rev": "98-41ae8ea7ee6797f5",
   "_id": "@aws-sdk/middleware-retry",
   "readme": "# @aws-sdk/middleware-retry\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-retry/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-retry)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-retry.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-retry)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{dd/26/237edd9ba2fec5340cb5ed6d1f45e90ae616fd2a7c269ada6d19de2a33e24f02e050da2c578e7003e10053b70dd1c12ef6edc26198c6430a188cf3116a25 → 07/4b/1e2cbf4373f3c312d515a9521aaec59d54c54ffdd0555d3a7c8acc500817c2b8d32f52ce877498ac8adb24e4c055fbb7e312ac8ad4c6047c242654bfd8ad}

@@ -2776,7 +2776,7 @@
   "dist-tags": {
     "latest": "3.0.1"
   },
-  "_rev": "2462-cb844d8ce54fde4c",
+  "_rev": "2477-8e777173c8e32c20",
   "_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/{81/9e/29e18b5dd29f184b4ea9fe2e1e454f576a37a7e82eb630232a4325adfc02411e7538218b7b2541195fccc5486b64614b57ce1fb034510cd1ea04b6502ebb → 08/42/fe99651f0e651a7f1dcb023e1d4a8e512e2ed592ffe112325c72cdf957301f0c50a1834e7c683ea7ac0ad7ff33a09d60e315d8e1519f2865e43c3b086f53}

@@ -969,7 +969,7 @@
   "dist-tags": {
     "latest": "0.11.0"
   },
-  "_rev": "148-0d2c288dcad196f9",
+  "_rev": "156-1592eb18333e5ffb",
   "_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/{3e/05/6bc22535776f0403ec33f04dd4bcdf5e57f45d148eb2b1ad24e2b284a6d51451d77fab59e8523682970f70ce6d1feb976ed284c153c8a5fdb2e44a46fd16 → 0b/99/61fd96906e7257e48bb2e4f3c2e9aedcb6fc45a4f8f98da26292ac5b667263a05c1b04c470598fc7fae01f17e5e4635760bffea4a7da398723d92fdd1ce0}

@@ -11294,7 +11294,7 @@
     "latest": "3.374.0",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "109-e3b266d1e592c94d",
+  "_rev": "117-3b8c4b051d1b1268",
   "_id": "@aws-sdk/eventstream-serde-universal",
   "readme": "# @aws-sdk/eventstream-serde-universal\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/eventstream-serde-universal/latest.svg)](https://www.npmjs.com/package/@aws-sdk/eventstream-serde-universal)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/eventstream-serde-universal.svg)](https://www.npmjs.com/package/@aws-sdk/eventstream-serde-universal)\n\n> An internal package\n\n## Usage\n\nYou probably shouldn't, at least directly.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{ed/84/9a682c2b715c3758b893b5f90587ca17727eb7c0d9200ba598ec891fea2af789ff5efcad1f74dd571a1d046187f6e0129361b1c764b16916ab3abb1ba9f5 → 0c/c4/75be9b47097879a9bafa427c66d459d3b84fff4c0c28617e0dc5f4640b473c71ce3b23f479a1d4c473d05de2a8c0ef2d389e9845f7c30c76b78d337a73b6}

@@ -422,7 +422,7 @@
   "dist-tags": {
     "latest": "1.0.6"
   },
-  "_rev": "1737-ba4bb70354ba098c",
+  "_rev": "1752-44a20fc9bd09ad6e",
   "_id": "inflight",
   "readme": "# inflight\n\nAdd callbacks to requests in flight to avoid async duplication\n\n## USAGE\n\n```javascript\nvar inflight = require('inflight')\n\n// some request that does some stuff\nfunction req(key, callback) {\n  // key is any random string.  like a url or filename or whatever.\n  //\n  // will return either a falsey value, indicating that the\n  // request for this key is already in flight, or a new callback\n  // which when called will call all callbacks passed to inflightk\n  // with the same key\n  callback = inflight(key, callback)\n\n  // If we got a falsey value back, then there's already a req going\n  if (!callback) return\n\n  // this is where you'd fetch the url or whatever\n  // callback is also once()-ified, so it can safely be assigned\n  // to multiple events etc.  First call wins.\n  setTimeout(function() {\n    callback(null, key)\n  }, 100)\n}\n\n// only assigns a single setTimeout\n// when it dings, all cbs get called\nreq('foo', cb1)\nreq('foo', cb2)\nreq('foo', cb3)\nreq('foo', cb4)\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{6a/7a/c5f08b2b428e1252685100840eb5380817ff4aa0ae3f3bd3bc8d249e36d3eb678d4b444839af616e5457ba057117407855c5734ab6838f2a8ecab160e7b4 → 0d/a3/c92539d53177d31231601c5459892860ba4bca1dda8a2989dd44cfb1b01a73f2e292d86a812bc0ef82c7933b13e7ca9b0b38ee57abeb3a5ff35bbbaa7692}

@@ -5530,7 +5530,7 @@
   "dist-tags": {
     "latest": "14.2.0"
   },
-  "_rev": "1210-29cce203d373d6cf",
+  "_rev": "1215-717b98a4c349fce1",
   "_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/{9b/5a/0bc927d185d1af04fdb7928ab8665beadd6f7b99f1255463fb199f60bd4844014f76ff44f330dc69d008409dd303b92bc2a8459c67b88e9510342efa17fa → 0d/ca/a70ac6dd8c2a3843f005718d7fb7b7754be1edb8b9bd45fa5925bf1b161b0a4aff91dce1149c3f21b862fc544ec8507af6751cb2a966dbae7adb56426b05}

@@ -17145,7 +17145,7 @@
   "dist-tags": {
     "latest": "3.787.0"
   },
-  "_rev": "88-58aa388525a0521b",
+  "_rev": "92-aff71f88c4d6d281",
   "_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": {}

package/npm-cache/_cacache/content-v2/sha512/{be/c3/6712415595d79a6556a41a5eddf073e8960baa90d282d751a0310d9c56df97d725760ee916489e863a66f7f71cf69f467b4068e5368ad422c28982e56e96 → 0e/8a/e0cd213e9274008a6594670379a23ff3ff36213c447a6460fb2200127afd1f1e8ce42165cf3e8f808b39827ac1710c967c82d601b035fcb6ded50444eea5}

@@ -1767,7 +1767,7 @@
     "latest": "1.0.0",
     "next": "1.0.0-RC9"
   },
-  "_rev": "160-1579186a2c033dc2",
+  "_rev": "164-237e4a201877247d",
   "_id": "buffer-crc32",
   "readme": "# buffer-crc32\n\n[![NPM Version](https://img.shields.io/npm/v/buffer-crc32.svg)](https://npmjs.org/package/buffer-crc32)\n[![Build Status](https://github.com/brianloveswords/buffer-crc32/actions/workflows/ci.yml/badge.svg)](https://github.com/brianloveswords/buffer-crc32/actions/workflows/ci.yml)\n\ncrc32 that works with binary data and fancy character sets, outputs\nbuffer, signed or unsigned data and has tests.\n\nDerived from the sample CRC implementation in the PNG specification: http://www.w3.org/TR/PNG/#D-CRCAppendix\n\nThis package requires Node 8+ to work.\n\n# install\n\n```\nnpm install buffer-crc32\n```\n\n# example\n\n```js\nconst crc32 = require('buffer-crc32');\n// works with buffers\nconst buf = Buffer([0x00, 0x73, 0x75, 0x70, 0x20, 0x62, 0x72, 0x6f, 0x00]);\ncrc32(buf); // -> <Buffer 94 5a ab 4a>\n\n// has convenience methods for getting signed or unsigned ints\ncrc32.signed(buf); // -> -1805997238\ncrc32.unsigned(buf); // -> 2488970058\n\n// will cast to buffer if given a string, so you can\n// directly use foreign characters safely\ncrc32('自動販売機'); // -> <Buffer cb 03 1a c5>\n\n// and works in append mode too\nconst partialCrc = crc32('hey');\nconst partialCrc = crc32(' ', partialCrc);\nconst partialCrc = crc32('sup', partialCrc);\nconst partialCrc = crc32(' ', partialCrc);\nconst finalCrc = crc32('bros', partialCrc); // -> <Buffer 47 fa 55 70>\n```\n\n# tests\n\nThis was tested against the output of zlib's crc32 method. You can run\nthe tests with`npm test` (requires tap)\n\n# see also\n\nhttps://github.com/alexgorbatchev/node-crc, `crc.buffer.crc32` also\nsupports buffer inputs and return unsigned ints (thanks @tjholowaychuk).\n\n# license\n\nMIT/X11",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{e1/c7/3b55575e2974afa425d0a6400b42a68e2dd55391e76878e00d65806284032875cdf4ed42eb8ba3d5f086738becfd61328790f66476c190c70bfd9f0d2bd2 → 10/64/0a842630c2110788e35eadbe7b619637423ab4c0d6fe79a788f880823afa3c193fbb358c662b289fef9424efb24728d4b0249d0e77e8b22610b714f99a76}

@@ -18164,7 +18164,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "88-7d02e43c6d40990e",
+  "_rev": "92-c9f3d5f29f6f7310",
   "_id": "@aws-sdk/middleware-expect-continue",
   "readme": "# @aws-sdk/middleware-expect-continue\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-expect-continue/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-expect-continue)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-expect-continue.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-expect-continue)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0d/6e/810d7620c02948fa61643064329a7347c3f95f94816e55eaaf377f520d26fbda5ee86bf06ff4403aeed36bae8e7d13d905583e011bf5bb1200143b7cb347 → 10/a4/799338e87beba902a320c1e02699c22e9d88eee926ca702adb15f2cc353018aa1bff1efd057aaf4db49d7c9c9b715939dcefb874f4c34b7532a31f635f53}

@@ -4366,7 +4366,7 @@
     "latest": "4.2.11",
     "old": "3.0.12"
   },
-  "_rev": "2208-5bb77d4dcb26824b",
+  "_rev": "2224-1dff6f76a52004a8",
   "_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/{73/03/935b3036aea0852b0dcd3000ce8f119a0b102ba8751a5d95ac6d8bd52a582d7aa511d0a9d19155a726dc0eafa1e567a593c3bcb902eac4df0aa6257d4e6a → 12/80/b3db277d4ec379dcd7ac39ee65206468ef937dc252ba9c89edcc1c24452c2bdaf1c9d2fd956398e794c62828a6614ac4426731141c0841b541efe0b6976a}

@@ -1324,10 +1324,116 @@
         "tmp": "tmp/tr46_5.1.0_1742021399096_0.8984161523183427"
       },
       "_hasShrinkwrap": false
+    },
+    "5.1.1": {
+      "name": "tr46",
+      "version": "5.1.1",
+      "engines": {
+        "node": ">=18"
+      },
+      "description": "An implementation of the Unicode UTS #46: Unicode IDNA Compatibility Processing",
+      "main": "index.js",
+      "scripts": {
+        "test": "node --test",
+        "lint": "eslint",
+        "pretest": "node scripts/getLatestTests.js",
+        "prepublish": "node scripts/generateMappingTable.js && node scripts/generateRegexes.js"
+      },
+      "repository": {
+        "type": "git",
+        "url": "git+https://github.com/jsdom/tr46.git"
+      },
+      "keywords": [
+        "unicode",
+        "tr46",
+        "uts46",
+        "punycode",
+        "url",
+        "whatwg"
+      ],
+      "author": {
+        "name": "Sebastian Mayr",
+        "email": "npm@smayr.name"
+      },
+      "contributors": [
+        {
+          "name": "Timothy Gu",
+          "email": "timothygu99@gmail.com"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "devDependencies": {
+        "@domenic/eslint-config": "^4.0.1",
+        "@unicode/unicode-16.0.0": "^1.6.5",
+        "eslint": "^9.22.0",
+        "globals": "^16.0.0",
+        "regenerate": "^1.4.2"
+      },
+      "unicodeVersion": "16.0.0",
+      "_id": "tr46@5.1.1",
+      "gitHead": "1999828c4c60e8f5672f0eb1fd4387e3f194923a",
+      "bugs": {
+        "url": "https://github.com/jsdom/tr46/issues"
+      },
+      "homepage": "https://github.com/jsdom/tr46#readme",
+      "_nodeVersion": "23.9.0",
+      "_npmVersion": "10.9.2",
+      "dist": {
+        "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+        "shasum": "96ae867cddb8fdb64a49cc3059a8d428bcf238ca",
+        "tarball": "https://verdaccio.mrsdev.ru/tr46/-/tr46-5.1.1.tgz",
+        "fileCount": 7,
+        "unpackedSize": 225902,
+        "signatures": [
+          {
+            "keyid": "SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U",
+            "sig": "MEYCIQCM5FspyM1JqI952qATQNDdTUWl5ww/y+c4pbi1BkNOowIhAOr0kzhk2lavDFpu7UXMDicPJTpdYbzrlOysqVU3Yunr"
+          }
+        ]
+      },
+      "_npmUser": {
+        "name": "domenic",
+        "email": "d@domenic.me"
+      },
+      "directories": {},
+      "maintainers": [
+        {
+          "name": "timothygu",
+          "email": "timothygu99@gmail.com"
+        },
+        {
+          "name": "domenic",
+          "email": "d@domenic.me"
+        },
+        {
+          "name": "sebmaster",
+          "email": "sebmaster16@gmail.com"
+        },
+        {
+          "name": "zirro",
+          "email": "code@zirro.se"
+        },
+        {
+          "name": "tmpvar",
+          "email": "tmpvar@gmail.com"
+        },
+        {
+          "name": "joris-van-der-wel",
+          "email": "joris@jorisvanderwel.com"
+        }
+      ],
+      "_npmOperationalInternal": {
+        "host": "s3://npm-registry-packages-npm-production",
+        "tmp": "tmp/tr46_5.1.1_1744850857969_0.06598419533962097"
+      },
+      "_hasShrinkwrap": false
     }
   },
   "time": {
-    "modified": "2025-03-15T06:49:59.480Z",
+    "modified": "2025-04-17T00:47:38.363Z",
     "created": "2015-06-06T07:11:07.303Z",
     "0.0.1": "2015-06-06T07:11:07.303Z",
     "0.0.2": "2015-06-06T15:17:30.114Z",
@@ -1343,13 +1449,14 @@
     "4.1.0": "2023-01-25T02:20:29.915Z",
     "4.1.1": "2023-03-08T06:56:42.196Z",
     "5.0.0": "2023-11-05T04:55:09.811Z",
-    "5.1.0": "2025-03-15T06:49:59.284Z"
+    "5.1.0": "2025-03-15T06:49:59.284Z",
+    "5.1.1": "2025-04-17T00:47:38.158Z"
   },
   "users": {},
   "dist-tags": {
-    "latest": "5.1.0"
+    "latest": "5.1.1"
   },
-  "_rev": "510-0f7ecc6166db6dc5",
+  "_rev": "514-d796b6fff5b8c294",
   "_id": "tr46",
   "readme": "# tr46\n\nAn JavaScript implementation of [Unicode Technical Standard #46: Unicode IDNA Compatibility Processing](https://unicode.org/reports/tr46/).\n\n## API\n\n### `toASCII(domainName[, options])`\n\nConverts a string of Unicode symbols to a case-folded Punycode string of ASCII symbols.\n\nAvailable options:\n\n* [`checkBidi`](#checkbidi)\n* [`checkHyphens`](#checkhyphens)\n* [`checkJoiners`](#checkjoiners)\n* [`ignoreInvalidPunycode`](#ignoreinvalidpunycode)\n* [`transitionalProcessing`](#transitionalprocessing)\n* [`useSTD3ASCIIRules`](#usestd3asciirules)\n* [`verifyDNSLength`](#verifydnslength)\n\n### `toUnicode(domainName[, options])`\n\nConverts a case-folded Punycode string of ASCII symbols to a string of Unicode symbols.\n\nAvailable options:\n\n* [`checkBidi`](#checkbidi)\n* [`checkHyphens`](#checkhyphens)\n* [`checkJoiners`](#checkjoiners)\n* [`ignoreInvalidPunycode`](#ignoreinvalidpunycode)\n* [`transitionalProcessing`](#transitionalprocessing)\n* [`useSTD3ASCIIRules`](#usestd3asciirules)\n\n## Options\n\n### `checkBidi`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, any bi-directional text within the input will be checked for validation.\n\n### `checkHyphens`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, the positions of any hyphen characters within the input will be checked for validation.\n\n### `checkJoiners`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, any word joiner characters within the input will be checked for validation.\n\n### `ignoreInvalidPunycode`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, invalid Punycode strings within the input will be allowed.\n\n### `transitionalProcessing`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, uses [transitional (compatibility) processing](https://unicode.org/reports/tr46/#Compatibility_Processing) of the deviation characters.\n\n### `useSTD3ASCIIRules`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, input will be validated according to [STD3 Rules](http://unicode.org/reports/tr46/#STD3_Rules).\n\n### `verifyDNSLength`\n\nType: `boolean`\nDefault value: `false`\nWhen set to `true`, the length of each DNS label within the input will be checked for validation.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{66/ec/3df2fadc377971c95708bbb8005e8da0775f60d2c75e76004254a66bbad26a27b469a016797acd6a055a92bfd222bd3d3975959b6a66a9d280e6a8ea685b → 12/f0/3ebf4772995d7a12c69f785a4b38c6dbea8c9ad54f5088ff78b250d44661275a35acf8045bd33664c07f4aeea034c3ddf3d2579de9d35712a1e08ab62f68}

@@ -11391,7 +11391,7 @@
     "gamma": "1.0.0-gamma.8",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "95-acb7cec0133027fe",
+  "_rev": "99-1cd896f14977336d",
   "_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/{0b/ee/1bbe0fb82883a8ea80af06935c3afbaef04a145c6baa4ec97f56816727e395a850e0cfc34f9cf871b241b11637b3b2a294f69c227fd0993be266db40a556 → 17/47/5b942bb34f050b87d827d6b0ec87b740ceb4685a32032557701d169725d7abb7bb90100788fd508eaee9c6aaf1043c6e775ed6eb00f00af2beafaef52206}

@@ -851,7 +851,7 @@
   "dist-tags": {
     "latest": "1.4.4"
   },
-  "_rev": "1064-28dde06ddeef714a",
+  "_rev": "1072-05ac2b2cdaba0756",
   "_id": "end-of-stream",
   "readme": "# end-of-stream\n\nA node module that calls a callback when a readable/writable/duplex stream has completed or failed.\n\n\tnpm install end-of-stream\n\n[![Build status](https://travis-ci.org/mafintosh/end-of-stream.svg?branch=master)](https://travis-ci.org/mafintosh/end-of-stream)\n\n## Usage\n\nSimply pass a stream and a callback to the `eos`.\nBoth legacy streams, streams2 and stream3 are supported.\n\n``` js\nvar eos = require('end-of-stream');\n\neos(readableStream, function(err) {\n  // this will be set to the stream instance\n\tif (err) return console.log('stream had an error or closed early');\n\tconsole.log('stream has ended', this === readableStream);\n});\n\neos(writableStream, function(err) {\n\tif (err) return console.log('stream had an error or closed early');\n\tconsole.log('stream has finished', this === writableStream);\n});\n\neos(duplexStream, function(err) {\n\tif (err) return console.log('stream had an error or closed early');\n\tconsole.log('stream has ended and finished', this === duplexStream);\n});\n\neos(duplexStream, {readable:false}, function(err) {\n\tif (err) return console.log('stream had an error or closed early');\n\tconsole.log('stream has finished but might still be readable');\n});\n\neos(duplexStream, {writable:false}, function(err) {\n\tif (err) return console.log('stream had an error or closed early');\n\tconsole.log('stream has ended but might still be writable');\n});\n\neos(readableStream, {error:false}, function(err) {\n\t// do not treat emit('error', err) as a end-of-stream\n});\n```\n\n## License\n\nMIT\n\n## Related\n\n`end-of-stream` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{76/53/c85ba19c523acf0c3f3c06fff9d0db56dfe0c442198665aebdd9841bda479d156b0c5fc6222a6d113d94fd3cf15ad8031170733a2ff1c2b658978c44c700 → 18/2c/fb120c8c978657c933abaec4f96ef909c61b30451ace65f2dd7abb830b3d689a9d762099552f240f5f8fce432ec220b6e6f264d1fbd2be956729e7cc7d27}

@@ -18006,7 +18006,7 @@
     "gamma": "1.0.0-gamma.9",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "101-adee9e4ffacad399",
+  "_rev": "105-076fbae0ec92af4a",
   "_id": "@aws-sdk/middleware-host-header",
   "readme": "# @aws-sdk/middleware-host-header\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-host-header/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-host-header)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-host-header.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-host-header)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{73/9f/79f45d504ed15bcf9873320f7d85b027ab86f86b531a12b66d95602331e39a00db9444c494e4eac38b6b5f1e6ce56c024deb284b4bbff7b5f8de76aee7f3 → 18/61/0262b3c1936e407425dd979c1a21081fbd8bde9b402d0e8c857d90bb138dd3c3651cc096b65984aef24bf7552be6397b3bb36075d77315ddaadc422d60ec}

@@ -7129,7 +7129,7 @@
     "latest": "4.1.0",
     "v3-legacy": "3.4.3"
   },
-  "_rev": "188-612b6a199a2542a8",
+  "_rev": "197-0b53de5be56fee4f",
   "_id": "jackspeak",
   "readme": "# jackspeak\n\nA very strict and proper argument parser.\n\nValidate string, boolean, and number options, from the command\nline and the environment.\n\nCall the `jack` method with a config object, and then chain\nmethods off of it.\n\nAt the end, call the `.parse()` method, and you'll get an object\nwith `positionals` and `values` members.\n\nAny unrecognized configs or invalid values will throw an error.\n\nAs long as you define configs using object literals, types will\nbe properly inferred and TypeScript will know what kinds of\nthings you got.\n\nIf you give it a prefix for environment variables, then defaults\nwill be read from the environment, and parsed values written back\nto it, so you can easily pass configs through to child processes.\n\nAutomatically generates a `usage`/`help` banner by calling the\n`.usage()` method.\n\nUnless otherwise noted, all methods return the object itself.\n\n## USAGE\n\n```js\nimport { jack } from 'jackspeak'\n// this works too:\n// const { jack } = require('jackspeak')\n\nconst { positionals, values } = jack({ envPrefix: 'FOO' })\n  .flag({\n    asdf: { description: 'sets the asfd flag', short: 'a', default: true },\n    'no-asdf': { description: 'unsets the asdf flag', short: 'A' },\n    foo: { description: 'another boolean', short: 'f' },\n  })\n  .optList({\n    'ip-addrs': {\n      description: 'addresses to ip things',\n      delim: ',', // defaults to '\\n'\n      default: ['127.0.0.1'],\n    },\n  })\n  .parse([\n    'some',\n    'positional',\n    '--ip-addrs',\n    '192.168.0.1',\n    '--ip-addrs',\n    '1.1.1.1',\n    'args',\n    '--foo', // sets the foo flag\n    '-A', // short for --no-asdf, sets asdf flag to false\n  ])\n\nconsole.log(process.env.FOO_ASDF) // '0'\nconsole.log(process.env.FOO_FOO) // '1'\nconsole.log(values) // {\n//   'ip-addrs': ['192.168.0.1', '1.1.1.1'],\n//   foo: true,\n//   asdf: false,\n// }\nconsole.log(process.env.FOO_IP_ADDRS) // '192.168.0.1,1.1.1.1'\nconsole.log(positionals) // ['some', 'positional', 'args']\n```\n\n## `jack(options: JackOptions = {}) => Jack`\n\nReturns a `Jack` object that can be used to chain and add\nfield definitions. The other methods (apart from `validate()`,\n`parse()`, and `usage()` obviously) return the same Jack object,\nupdated with the new types, so they can be chained together as\nshown in the code examples.\n\nOptions:\n\n- `allowPositionals` Defaults to true. Set to `false` to not\n  allow any positional arguments.\n\n- `envPrefix` Set to a string to write configs to and read\n  configs from the environment. For example, if set to `MY_APP`\n  then the `foo-bar` config will default based on the value of\n  `env.MY_APP_FOO_BAR` and will write back to that when parsed.\n\n  Boolean values are written as `'1'` and `'0'`, and will be\n  treated as `true` if they're `'1'` or false otherwise.\n\n  Number values are written with their `toString()`\n  representation.\n\n  Strings are just strings.\n\n  Any value with `multiple: true` will be represented in the\n  environment split by a delimiter, which defaults to `\\n`.\n\n- `env` The place to read/write environment variables. Defaults\n  to `process.env`.\n\n- `usage` A short usage string to print at the top of the help\n  banner.\n\n- `stopAtPositional` Boolean, default false. Stop parsing opts\n  and flags at the first positional argument. This is useful if\n  you want to pass certain options to subcommands, like some\n  programs do, so you can stop parsing and pass the positionals\n  to the subcommand to parse.\n\n- `stopAtPositionalTest` Conditional `stopAtPositional`. Provide\n  a function that takes a positional argument string and returns\n  boolean. If it returns `true`, then parsing will stop. Useful\n  when _some_ subcommands should parse the rest of the command\n  line options, and others should not.\n\n### `Jack.heading(text: string, level?: 1 | 2 | 3 | 4 | 5 | 6)`\n\nDefine a short string heading, used in the `usage()` output.\n\nIndentation of the heading and subsequent description/config\nusage entries (up until the next heading) is set by the heading\nlevel.\n\nIf the first usage item defined is a heading, it is always\ntreated as level 1, regardless of the argument provided.\n\nHeadings level 1 and 2 will have a line of padding underneath\nthem. Headings level 3 through 6 will not.\n\n### `Jack.description(text: string, { pre?: boolean } = {})`\n\nDefine a long string description, used in the `usage()` output.\n\nIf the `pre` option is set to `true`, then whitespace will not be\nnormalized. However, if any line is too long for the width\nallotted, it will still be wrapped.\n\n## Option Definitions\n\nConfigs are defined by calling the appropriate field definition\nmethod with an object where the keys are the long option name,\nand the value defines the config.\n\nOptions:\n\n- `type` Only needed for the `addFields` method, as the others\n  set it implicitly. Can be `'string'`, `'boolean'`, or\n  `'number'`.\n- `multiple` Only needed for the `addFields` method, as the\n  others set it implicitly. Set to `true` to define an array\n  type. This means that it can be set on the CLI multiple times,\n  set as an array in the `values`\n  and it is represented in the environment as a delimited string.\n- `short` A one-character shorthand for the option.\n- `description` Some words to describe what this option is and\n  why you'd set it.\n- `hint` (Only relevant for non-boolean types) The thing to show\n  in the usage output, like `--option=<hint>`\n- `validate` A function that returns false (or throws) if an\n  option value is invalid.\n- `validOptions` An array of strings or numbers that define the\n  valid values that can be set. This is not allowed on `boolean`\n  (flag) options. May be used along with a `validate()` method.\n- `default` A default value for the field. Note that this may be\n  overridden by an environment variable, if present.\n\n### `Jack.flag({ [option: string]: definition, ... })`\n\nDefine one or more boolean fields.\n\nBoolean options may be set to `false` by using a\n`--no-${optionName}` argument, which will be implicitly created\nif it's not defined to be something else.\n\nIf a boolean option named `no-${optionName}` with the same\n`multiple` setting is in the configuration, then that will be\ntreated as a negating flag.\n\n### `Jack.flagList({ [option: string]: definition, ... })`\n\nDefine one or more boolean array fields.\n\n### `Jack.num({ [option: string]: definition, ... })`\n\nDefine one or more number fields. These will be set in the\nenvironment as a stringified number, and included in the `values`\nobject as a number.\n\n### `Jack.numList({ [option: string]: definition, ... })`\n\nDefine one or more number list fields. These will be set in the\nenvironment as a delimited set of stringified numbers, and\nincluded in the `values` as a number array.\n\n### `Jack.opt({ [option: string]: definition, ... })`\n\nDefine one or more string option fields.\n\n### `Jack.optList({ [option: string]: definition, ... })`\n\nDefine one or more string list fields.\n\n### `Jack.addFields({ [option: string]: definition, ... })`\n\nDefine one or more fields of any type. Note that `type` and\n`multiple` must be set explicitly on each definition when using\nthis method.\n\n## Informative Getters\n\nOnce you've defined several fields with the various methods\ndescribed above, you can get at the definitions and such with\nthese methods.\n\nThis are primarily just informative, but can be useful in some\nadvanced scenarios, such as providing \"Did you mean?\" type\nsuggestions when someone misspells an option name.\n\n### `Jack.definitions`\n\nThe set of config field definitions in no particular order. This\nis a data object suitable to passing to `util.parseArgs`, but\nwith the addition of `short` and `description` fields, where\nappropriate.\n\n### `Jack.jackOptions`\n\nThe options passed into the initial `jack()` function (or `new\nJack()` constructor).\n\n### `Jack.shorts`\n\nThe `{ <short>: <long> }` name record for all short options\ndefined.\n\n### `Jack.usageFields`\n\nThe array of fields that are used to generate `Jack.usage()` and\n`Jack.usageMarkdown()` content.\n\n## Actions\n\nUse these methods on a Jack object that's already had its config\nfields defined.\n\n### `Jack.parse(args: string[] = process.argv): { positionals: string[], values: OptionsResults }`\n\nParse the arguments list, write to the environment if `envPrefix`\nis set, and returned the parsed values and remaining positional\narguments.\n\n### `Jack.validate(o: any): asserts o is OptionsResults`\n\nThrows an error if the object provided is not a valid result set,\nfor the configurations defined thusfar.\n\n### `Jack.usage(): string`\n\nReturns the compiled `usage` string, with all option descriptions\nand heading/description text, wrapped to the appropriate width\nfor the terminal.\n\n### `Jack.setConfigValues(options: OptionsResults, src?: string)`\n\nValidate the `options` argument, and set the default value for\neach field that appears in the options.\n\nValues provided will be overridden by environment variables or\ncommand line arguments.\n\n### `Jack.usageMarkdown(): string`\n\nReturns the compiled `usage` string, with all option descriptions\nand heading/description text, but as markdown instead of\nformatted for a terminal, for generating HTML documentation for\nyour CLI.\n\n## Some Example Code\n\nAlso see [the examples\nfolder](https://github.com/isaacs/jackspeak/tree/master/examples)\n\n```js\nimport { jack } from 'jackspeak'\n\nconst j = jack({\n  // Optional\n  // This will be auto-generated from the descriptions if not supplied\n  // top level usage line, printed by -h\n  // will be auto-generated if not specified\n  usage: 'foo [options] <files>',\n})\n  .heading('The best Foo that ever Fooed')\n  .description(\n    `\n    Executes all the files and interprets their output as\n    TAP formatted test result data.\n\n    To parse TAP data from stdin, specify \"-\" as a filename.\n  `,\n  )\n\n  // flags don't take a value, they're boolean on or off, and can be\n  // turned off by prefixing with `--no-`\n  // so this adds support for -b to mean --bail, or -B to mean --no-bail\n  .flag({\n    flag: {\n      // specify a short value if you like.  this must be a single char\n      short: 'f',\n      // description is optional as well.\n      description: `Make the flags wave`,\n      // default value for flags is 'false', unless you change it\n      default: true,\n    },\n    'no-flag': {\n      // you can can always negate a flag with `--no-flag`\n      // specifying a negate option will let you define a short\n      // single-char option for negation.\n      short: 'F',\n      description: `Do not wave the flags`,\n    },\n  })\n\n  // Options that take a value are specified with `opt()`\n  .opt({\n    reporter: {\n      short: 'R',\n      description: 'the style of report to display',\n    },\n  })\n\n  // if you want a number, say so, and jackspeak will enforce it\n  .num({\n    jobs: {\n      short: 'j',\n      description: 'how many jobs to run in parallel',\n      default: 1,\n    },\n  })\n\n  // A list is an option that can be specified multiple times,\n  // to expand into an array of all the settings.  Normal opts\n  // will just give you the last value specified.\n  .optList({\n    'node-arg': {},\n  })\n\n  // a flagList is an array of booleans, so `-ddd` is [true, true, true]\n  // count the `true` values to treat it as a counter.\n  .flagList({\n    debug: { short: 'd' },\n  })\n\n  // opts take a value, and is set to the string in the results\n  // you can combine multiple short-form flags together, but\n  // an opt will end the combine chain, posix-style.  So,\n  // -bofilename would be like --bail --output-file=filename\n  .opt({\n    'output-file': {\n      short: 'o',\n      // optional: make it -o<file> in the help output insead of -o<value>\n      hint: 'file',\n      description: `Send the raw output to the specified file.`,\n    },\n  })\n\n// now we can parse argv like this:\nconst { values, positionals } = j.parse(process.argv)\n\n// or decide to show the usage banner\nconsole.log(j.usage())\n\n// or validate an object config we got from somewhere else\ntry {\n  j.validate(someConfig)\n} catch (er) {\n  console.error('someConfig is not valid!', er)\n}\n```\n\n## Name\n\nThe inspiration for this module is [yargs](http://npm.im/yargs), which\nis pirate talk themed. Yargs has all the features, and is infinitely\nflexible. \"Jackspeak\" is the slang of the royal navy. This module\ndoes not have all the features. It is declarative and rigid by design.",
   "_attachments": {}