{"_id":"neoqs","_rev":"8-3ccc39210b4f5c8be75ac0bf240d5a7e","name":"neoqs","dist-tags":{"latest":"6.13.0"},"versions":{"0.0.1":{"name":"neoqs","version":"0.0.1","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@0.0.1","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"01cab993c84cdebd87f16d18abdd7d4d1a644fbd","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-0.0.1.tgz","fileCount":12,"integrity":"sha512-lnsSePjNaXQjyOgIh4gm1I25YsVnF8pQ9bH2+bAXfH9773PTMOj+DZgodXa0SUHy08L5FKLKZzqq2BdTer7LBw==","signatures":[{"sig":"MEUCIQDIwNLeu8SENsdnvw9b7uWYNJpgyKT707Ai7q8DtQWCfgIgMCCq2zLbaXtT9eqkIyxMtB0SBqv3/ILaf5SBaBkalDk=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":211346},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":{"default":"./dist/index.js","production":"./dist/min/index.js","development":"./dist/index.js"},"default":"./dist/min/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"d53daffe2aedb5832c699711134013b621ffd238","scripts":{"test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts","publish":"npm run compile && npm publish --no-git-checks --access public"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_0.0.1_1721716779697_0.7500959982103799","host":"s3://npm-registry-packages"}},"0.0.2":{"name":"neoqs","version":"0.0.2","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@0.0.2","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"389b68fa45e8f1313ff5cf1b2e8c87fffbe47883","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-0.0.2.tgz","fileCount":12,"integrity":"sha512-py00fTYedN9YrRnTrXyM7PYZLyzQokzhNmXEaecs7CcZzfaSglo5CdeSlyPqRiOJx5JyafdlIQ2OSAXMF/xtlQ==","signatures":[{"sig":"MEYCIQCxpWJL9m3fvQ0RSbdf0Yc4ReLgWP1fg62OwsLM174/UwIhAIZ0pIg7GqVwGAjuRYEj9r8C+E+7YWdLjFKcGsXAUWgq","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":211342},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":{"default":"./dist/index.js","production":"./dist/min/index.js","development":"./dist/index.js"},"default":"./dist/min/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"d53daffe2aedb5832c699711134013b621ffd238","scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_0.0.2_1721716815911_0.8521938245013554","host":"s3://npm-registry-packages"}},"6.2.12":{"name":"neoqs","version":"6.2.12","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.2.12","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"182a3664e1efa7cb4de50478cc6f9f798e9d8eff","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.2.12.tgz","fileCount":12,"integrity":"sha512-lI3BSbH3Xqu4/IKJvt7kXdfTnZPg4shcQT5yeYWktrfOEigajrjjh1IvC4TrqCUk4wZpQuRzKUFbpNgBy/cNLQ==","signatures":[{"sig":"MEUCIQC/gyeHEtaSbiETHcPtuZLoycgqPPY0qNNqAalLGgcB9AIgAsusvNcBdoOkp2mzr5UYS5o00RvWpcFDIsLYXYpUwgg=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":212095},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":{"default":"./dist/index.js","production":"./dist/min/index.js","development":"./dist/index.js"},"default":"./dist/min/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"07bca882a2cf0fe449cfd7e7fe83fb6a87f1421d","scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.2.12_1721721200241_0.3794967335821864","host":"s3://npm-registry-packages"}},"6.12.3":{"name":"neoqs","version":"6.12.3","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.12.3","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"41712c64fcbf9ba3bdb8dcc0da2de0ed8ce40d5f","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.12.3.tgz","fileCount":12,"integrity":"sha512-49T7eZocIfmWbdWT4m1QJ0XjYZ6hGalpNnMcY8c1ex3NbcG/9mwrk8EtBwUXJJ1d79sf3KJ3KFQ2rdAKecWenA==","signatures":[{"sig":"MEQCIBsZrwuvPd8Hoi7BP291GBML8KR3pG43FQIC+ePlj5YNAiBVPBz8/3P8K9vxIxm4VxIO5UHLMk3qsYz7hEGWOw8+2g==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":212095},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":{"default":"./dist/index.js","production":"./dist/min/index.js","development":"./dist/index.js"},"default":"./dist/min/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"1443ff08a71a235a1e72badad1f0d7503f96ddaf","scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.12.3_1721731652934_0.3887334671877667","host":"s3://npm-registry-packages"}},"6.12.4":{"name":"neoqs","version":"6.12.4","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.12.4","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"e0ef0f282226536356fecfc0a2c8b7a8e995692e","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.12.4.tgz","fileCount":13,"integrity":"sha512-vFDHSwZwJw6ziCxtR07efPKVTF7HaWTmm/dD6asFh26z2jHmjg7s2ofXvWaO7HtWy5ED1b9BUKT5kwOp//cp+g==","signatures":[{"sig":"MEUCIExgLn2rCWrXICdzTzJjRxI2tOUTP5K5JJuOzPIJcurLAiEAgAwF92rNtsUrg0QhbzPL8LFQbTVwKK8VPoQCHwIC6jY=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":214368},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":{"default":"./dist/index.js","production":"./dist/min/index.js","development":"./dist/index.js"},"default":"./dist/min/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"c930c5e2069cc1d570d0236064951a6c1d0ef718","scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.12.4_1723034847204_0.41186104834782555","host":"s3://npm-registry-packages"}},"6.12.5":{"name":"neoqs","version":"6.12.5","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.12.5","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/puruvj/neoqs","bugs":{"url":"https://github.com/puruvj/neoqs/issues"},"dist":{"shasum":"7c456c126934ee71fba1666c75a80eadd39b096f","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.12.5.tgz","fileCount":13,"integrity":"sha512-KNczXnyuZukdwusNJmgSQifrJUvx45Vg/ka2aNUgONEIqTrZmwBPubI5X86SZG29ZtCnQjS+27CCmxi8AGLhfQ==","signatures":[{"sig":"MEUCIQCdzXL5P5QI3au1BIPDPJOK8lbBZa8fsMwOS6gvbKe9ygIgDH4ZruxMI6EqJVkQTdue4HzZG2Ehf3ApGO9UxSduHtw=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":214263},"main":"./dist/legacy/legacy.cjs","type":"module","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","default":"./dist/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"gitHead":"1f2f34d34792c734595cccceba9efdeb1fcffa58","scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"repository":{"url":"git+https://github.com/puruvj/neoqs.git","type":"git"},"_npmVersion":"10.8.1","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"22.3.0","_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.12.5_1723208202982_0.9988448605564277","host":"s3://npm-registry-packages"}},"6.12.6":{"name":"neoqs","version":"6.12.6","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.12.6","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/PuruVJ/neoqs","bugs":{"url":"https://github.com/PuruVJ/neoqs/issues"},"dist":{"shasum":"6bab07138c29b771eec28c3654615b9c1577a1ad","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.12.6.tgz","fileCount":3,"integrity":"sha512-v38t6OHJswldo/EgIdwMaGDW9PDxcznIhfMx8N4g6F01u20qjeV6L2naL92fi2IHkrzxFaJTldm+3/crSOrs1g==","signatures":[{"sig":"MEYCIQCZxh/n4gpQrXl9GlrpPgo8Z+K52cu7mqRx2raYrdaRmwIhAI6OmbcJJm3sNWNjIBWZ+v/l7fvbNe1Dp2y2k4NGO8Dm","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"attestations":{"url":"https://registry.npmjs.org/-/npm/v1/attestations/neoqs@6.12.6","provenance":{"predicateType":"https://slsa.dev/provenance/v1"}},"unpackedSize":28851},"main":"./dist/legacy/legacy.cjs","type":"module","_from":"file:neoqs-6.12.6.tgz","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","default":"./dist/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts","changeset":"changeset","ci:release":"changeset publish","ci:version":"changeset version"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"_resolved":"/tmp/6d3da836efcf2c8b4d16f2245e3783bd/neoqs-6.12.6.tgz","_integrity":"sha512-v38t6OHJswldo/EgIdwMaGDW9PDxcznIhfMx8N4g6F01u20qjeV6L2naL92fi2IHkrzxFaJTldm+3/crSOrs1g==","repository":{"url":"git+https://github.com/PuruVJ/neoqs.git","type":"git"},"_npmVersion":"10.7.0","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"18.20.4","publishConfig":{"provenance":true},"_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@changesets/cli":"^2.27.7","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.12.6_1723217995837_0.9850661961038623","host":"s3://npm-registry-packages"}},"6.12.7":{"name":"neoqs","version":"6.12.7","keywords":["querystring","qs","query","url","parse","stringify"],"license":"BSD-3-Clause","_id":"neoqs@6.12.7","maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"contributors":[{"url":"http://x.com/puruvjdev","name":"Puru Vijay"}],"homepage":"https://github.com/PuruVJ/neoqs","bugs":{"url":"https://github.com/PuruVJ/neoqs/issues"},"dist":{"shasum":"0ec7b3b4e222f6db78242afc521cc324ec611170","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.12.7.tgz","fileCount":13,"integrity":"sha512-SQS9qvPl7rhDWy/7vOChlDBotYKCtO0gnabeT8NXeWLRQVKwjt+lECEuVx63PJXW/c0VQXzy0B4+GUEvXq5SrA==","signatures":[{"sig":"MEYCIQDiixnv+Vql82kzsVRYf5WttjrO89QRzoNPNy+7WYlJIAIhAKZAAex/0suvizuIUkDQ6GUXpsbBinZKL8emL4K8VE5P","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"attestations":{"url":"https://registry.npmjs.org/-/npm/v1/attestations/neoqs@6.12.7","provenance":{"predicateType":"https://slsa.dev/provenance/v1"}},"unpackedSize":214575},"main":"./dist/legacy/legacy.cjs","type":"module","_from":"file:neoqs-6.12.7.tgz","types":"./dist/legacy/legacy.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","default":"./dist/index.js"},"./legacy":{"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs","require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"}},"./package.json":"./package.json"},"scripts":{"pub":"npm run compile && npm publish --no-git-checks --access public","test":"vitest run --coverage","compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts","changeset":"changeset","ci:release":"changeset publish","ci:version":"changeset version"},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"_resolved":"/tmp/78a943863de224c0c82bc47971fa26d3/neoqs-6.12.7.tgz","_integrity":"sha512-SQS9qvPl7rhDWy/7vOChlDBotYKCtO0gnabeT8NXeWLRQVKwjt+lECEuVx63PJXW/c0VQXzy0B4+GUEvXq5SrA==","repository":{"url":"git+https://github.com/PuruVJ/neoqs.git","type":"git"},"_npmVersion":"10.7.0","description":"A querystring parser that supports nesting and arrays, with a depth limit","directories":{},"sideEffects":false,"_nodeVersion":"18.20.4","publishConfig":{"provenance":true},"_hasShrinkwrap":false,"devDependencies":{"tsup":"^8.2.0","terser":"^5.31.3","vitest":"^2.0.3","@swc/core":"^1.7.0","iconv-lite":"^0.5.2","typescript":"^5.5.3","@changesets/cli":"^2.27.7","@vitest/coverage-v8":"^2.0.3"},"_npmOperationalInternal":{"tmp":"tmp/neoqs_6.12.7_1723222572584_0.029216778983465197","host":"s3://npm-registry-packages"}},"6.13.0":{"name":"neoqs","description":"A querystring parser that supports nesting and arrays, with a depth limit","homepage":"https://github.com/PuruVJ/neoqs","version":"6.13.0","type":"module","repository":{"type":"git","url":"git+https://github.com/PuruVJ/neoqs.git"},"main":"./dist/legacy/legacy.cjs","sideEffects":false,"contributors":[{"name":"Puru Vijay","url":"http://x.com/puruvjdev"}],"exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","default":"./dist/index.js"},"./legacy":{"require":{"types":"./dist/legacy/legacy.d.cts","default":"./dist/legacy/legacy.cjs"},"import":{"types":"./dist/legacy/legacy.d.ts","default":"./dist/legacy/legacy.mjs"},"default":"./dist/legacy/legacy.cjs"},"./package.json":"./package.json"},"publishConfig":{"provenance":true},"keywords":["querystring","qs","query","url","parse","stringify"],"devDependencies":{"@changesets/cli":"^2.27.7","@swc/core":"^1.7.0","@vitest/coverage-v8":"^2.0.3","iconv-lite":"^0.5.2","terser":"^5.31.3","tsup":"^8.2.0","typescript":"^5.5.3","vitest":"^2.0.3"},"license":"BSD-3-Clause","scripts":{"compile":"tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.ts legacy.d.ts","test":"vitest run --coverage","pub":"npm run compile && npm publish --no-git-checks --access public","changeset":"changeset","ci:version":"changeset version","ci:release":"changeset publish"},"_id":"neoqs@6.13.0","types":"./dist/legacy/legacy.d.ts","bugs":{"url":"https://github.com/PuruVJ/neoqs/issues"},"_integrity":"sha512-IysBpjrEG9qiUb/IT6XrXSz2ASzBxLebp4s8/GBm7STYC315vMNqH0aWdRR+f7KvXK4aRlLcf5r2Z6dOTxQSrQ==","_resolved":"/tmp/6172638f137b024179e50d3947bc9c1b/neoqs-6.13.0.tgz","_from":"file:neoqs-6.13.0.tgz","_nodeVersion":"18.20.4","_npmVersion":"10.7.0","dist":{"integrity":"sha512-IysBpjrEG9qiUb/IT6XrXSz2ASzBxLebp4s8/GBm7STYC315vMNqH0aWdRR+f7KvXK4aRlLcf5r2Z6dOTxQSrQ==","shasum":"a034bccafefdf8c01fcf4f45fee0aed4b75b4944","tarball":"https://registry.npmjs.org/neoqs/-/neoqs-6.13.0.tgz","fileCount":13,"unpackedSize":217091,"attestations":{"url":"https://registry.npmjs.org/-/npm/v1/attestations/neoqs@6.13.0","provenance":{"predicateType":"https://slsa.dev/provenance/v1"}},"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIEUWKLrDVkO9tRrHbhrklLe22pOFYQdy+KuU1wz++4TUAiAEsW2NLBjks4MpTpiC2QCfgEOkdfpUPNCHH8hblTBKUg=="}]},"_npmUser":{"name":"puruvj","email":"awesomepuruvj@gmail.com"},"directories":{},"maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/neoqs_6.13.0_1723636807703_0.5087324387442462"},"_hasShrinkwrap":false}},"time":{"created":"2024-07-23T06:39:39.593Z","modified":"2024-08-14T12:00:08.333Z","0.0.1":"2024-07-23T06:39:39.919Z","0.0.2":"2024-07-23T06:40:16.052Z","6.2.12":"2024-07-23T07:53:20.398Z","6.12.3":"2024-07-23T10:47:33.135Z","6.12.4":"2024-08-07T12:47:27.403Z","6.12.5":"2024-08-09T12:56:43.174Z","6.12.6":"2024-08-09T15:39:55.984Z","6.12.7":"2024-08-09T16:56:12.834Z","6.13.0":"2024-08-14T12:00:07.909Z"},"bugs":{"url":"https://github.com/PuruVJ/neoqs/issues"},"license":"BSD-3-Clause","homepage":"https://github.com/PuruVJ/neoqs","keywords":["querystring","qs","query","url","parse","stringify"],"repository":{"type":"git","url":"git+https://github.com/PuruVJ/neoqs.git"},"description":"A querystring parser that supports nesting and arrays, with a depth limit","contributors":[{"name":"Puru Vijay","url":"http://x.com/puruvjdev"}],"maintainers":[{"name":"puruvj","email":"awesomepuruvj@gmail.com"}],"readme":"# neoqs\n\nA querystring parsing and stringifying library with some added security. It is a fork and TypeScript rewrite of [qs](https://github.com/ljharb/qs) that aims to be modern, lightweight yet fully backwards compatible with `qs`.\n\nLead Maintainer: [Puru Vijay](https://github.com/puruvj)\n\nThe **qs** module was originally created and maintained by [TJ Holowaychuk](https://github.com/visionmedia/node-querystring).\n\n`neoqs` is not endorsed by the current maintainer of `qs`.\n\n---\n\n- 🤌 3.9KB min+brotli (3x smaller than `qs`)\n- 🚥 Zero dependencies\n- 🎹 TypeScript. Throw away the `@types/qs` package\n- ❎ No polyfills\n- 🛸 ESM-first\n- 📜 Legacy mode supporting ES5\n\nRules this package aims to follow for an indefinite period of time:\n\n- No dependencies.\n- No polyfills.\n- ESM-first.\n- Pushing to be modern\n- Always provide a legacy mode\n- Always follow `qs` API. There already are many packages that do this. `neoqs` intends to be a drop-in replacement for `qs` and provide the same API with 0 dependencies and enhanced Developer Experience.\n\n# When to use this package?\n\nThis package is intended to be a drop-in replacement for `qs` and provide the same API with 0 dependencies and enhanced Developer Experience. Hence, if you are already using `qs` in your project, you should use this package instead.\n\n## When \\*not\\* to use this package?\n\nIf your use-cases are very simple(`foo=bar&baz=baka`), mostly top-level keys(`foo=bar`), and not supporting really old browsers and Node versions, delete both `qs` and `neoqs` from your project and use [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) instead.\n\n# Which build to use?\n\n`neoqs` provides 2 builds:\n\n- default: Backwards compatible with `qs` and provides the same API, but ESM only and compiled to ES2022 with Node 18+\n- legacy: Legacy build with ES5 and CommonJS, compatible with `qs` and provides the same API. _Theoretically_ works as far back as Node 4.0.0, but it's not tested.\n\nHere's a matrix of the different builds:\n\n| Build   | ESM       | CJS | Browser | Node | Polyfills | Size             |\n| ------- | --------- | --- | ------- | ---- | --------- | ---------------- |\n| default | ✅ ES2022 |     | ✅      | ✅   | ❌        | 3.9KB min+brotli |\n| legacy  | ✅ ES5    | ✅  | ✅      | ✅   | ❌        | 4.2KB min+brotli |\n\nIf you:\n\n### are shipping a library with commonJS support:\n\nUse `legacy` build for compatibility with old browsers and Node versions.\n\n```js\nconst { parse, stringify } = require('neoqs/legacy');\n```\n\nESM:\n\n```js\nimport { parse, stringify } from 'neoqs/legacy';\n```\n\n### don't care about old browsers or Node versions:\n\nUse default build for no breaking changes, and a modern build for better developer experience.\n\n```ts\nimport * as qs from 'neoqs';\n\nconst obj = qs.parse('a=c');\nconsole.log(obj);\n\nconst str = qs.stringify(obj);\nconsole.log(str);\n```\n\n### and you care about old browsers or Node or CommonJS versions:\n\nUse legacy build for compatibility with old browsers and Node versions.\n\n```js\nconst { parse, stringify } = require('neoqs/legacy');\n```\n\nESM:\n\n```js\nimport { parse, stringify } from 'neoqs/legacy';\n```\n\n## Usage\n\n```js\nimport * as qs from 'neoqs';\n\nconst obj = qs.parse('a=c');\nconsole.log(obj);\n\nconst str = qs.stringify(obj);\nconsole.log(str);\n```\n\n### Parsing Objects\n\n[](#preventEval)\n\n```js\nparse(string, [options]);\n```\n\n**qs** allows you to create nested objects within your query strings, by surrounding the name of sub-keys with square brackets `[]`. For example, the string `'foo[bar]=baz'` converts to:\n\n```js\nconsole.log(qs.parse('foo[bar]=baz'));\n// Output:\n// {\n//  foo: {\n//    bar: 'baz'\n//  }\n//});\n```\n\nWhen using the `plainObjects` option the parsed value is returned as a null object, created via `Object.create(null)` and as such you should be aware that prototype methods will not exist on it and a user may set those names to whatever value they like:\n\n```js\nconst nullObject = qs.parse('a[hasOwnProperty]=b', { plainObjects: true });\nconsole.log(nullObject);\n// Output:\n// {\n//  a: {\n//    hasOwnProperty: 'b'\n//  }\n// }\n```\n\nBy default parameters that would overwrite properties on the object prototype are ignored, if you wish to keep the data from those fields either use `plainObjects` as mentioned above, or set `allowPrototypes` to `true` which will allow user input to overwrite those properties. _WARNING_ It is generally a bad idea to enable this option as it can cause problems when attempting to use the properties that have been overwritten. Always be careful with this option.\n\n```js\nconst protoObject = qs.parse('a[hasOwnProperty]=b', { allowPrototypes: true });\nconsole.log(protoObject);\n// Output:\n// {\n//  a: {\n//    hasOwnProperty: 'b'\n//  }\n// }\n```\n\nURI encoded strings work too:\n\n```js\nconsole.log(qs.parse('a%5Bb%5D=c'));\n// Output:\n// {\n//  a: {\n//    b: 'c'\n//  }\n// }\n```\n\nYou can also nest your objects, like `'foo[bar][baz]=foobarbaz'`:\n\n```js\nconsole.log(qs.parse('foo[bar][baz]=foobarbaz'));\n// Output:\n// {\n//  foo: {\n//    bar: {\n//      baz: 'foobarbaz'\n//    }\n//  }\n// }\n```\n\nBy default, when nesting objects **qs** will only parse up to 5 children deep. This means if you attempt to parse a string like `'a[b][c][d][e][f][g][h][i]=j'` your resulting object will be:\n\n```js\nconst expected = {\n  a: {\n    b: {\n      c: {\n        d: {\n          e: {\n            f: {\n              '[g][h][i]': 'j'\n            }\n          }\n        }\n      }\n    }\n  }\n};\nconsole.log(qs.stringify(expected));\n// Output:\n// 'a[b][c][d][e][f][g][h][i]=j'\n```\n\nThis depth can be overridden by passing a `depth` option to `qs.parse(string, [options])`:\n\n```js\nconst deep = qs.parse('a[b][c][d][e][f][g][h][i]=j', { depth: 1 });\nconsole.log(deep);\n// Output:\n// {\n//  a: {\n//    b: {\n//      '[c][d][e][f][g][h][i]': 'j'\n//    }\n//  }\n// }\n```\n\nYou can configure **qs** to throw an error when parsing nested input beyond this depth using the `strictDepth` option (defaulted to false):\n\n```js\ntry {\n  qs.parse('a[b][c][d][e][f][g][h][i]=j', { depth: 1, strictDepth: true });\n} catch (err) {\n  assert(err instanceof RangeError);\n  assert.strictEqual(err.message, 'Input depth exceeded depth option of 1 and strictDepth is true');\n}\n```\n\nThe depth limit helps mitigate abuse when **qs** is used to parse user input, and it is recommended to keep it a reasonably small number. The strictDepth option adds a layer of protection by throwing an error when the limit is exceeded, allowing you to catch and handle such cases.\n\nFor similar reasons, by default **qs** will only parse up to 1000 parameters. This can be overridden by passing a `parameterLimit` option:\n\n```js\nconst limited = qs.parse('a=b&c=d', { parameterLimit: 1 });\nconsole.log(limited);\n// Output:\n// {\n//  a: 'b'\n// }\n```\n\nTo bypass the leading question mark, use `ignoreQueryPrefix`:\n\n```js\nconst prefixed = qs.parse('?a=b&c=d', { ignoreQueryPrefix: true });\nconsole.log(prefixed);\n// Output:\n// {\n//  a: 'b',\n//  c: 'd'\n// }\n```\n\nAn optional delimiter can also be passed:\n\n```js\nconst delimited = qs.parse('a=b;c=d', { delimiter: ';' });\nconsole.log(delimited);\n// Output:\n// {\n//  a: 'b',\n//  c: 'd'\n// }\n```\n\nDelimiters can be a regular expression too:\n\n```js\nconst regexed = qs.parse('a=b;c=d,e=f', { delimiter: /[;,]/ });\nconsole.log(regexed);\n// Output:\n// {\n//  a: 'b',\n//  c: 'd',\n//  e: 'f'\n// }\n```\n\nOption `allowDots` can be used to enable dot notation:\n\n```js\nconst withDots = qs.parse('a.b=c', { allowDots: true });\nconsole.log(withDots);\n// Output:\n// {\n//  a: {\n//    b: 'c'\n//  }\n// }\n```\n\nOption `decodeDotInKeys` can be used to decode dots in keys Note: it implies `allowDots`, so `parse` will error if you set `decodeDotInKeys` to `true`, and `allowDots` to `false`.\n\n```js\nconst withDots = qs.parse('name%252Eobj.first=John&name%252Eobj.last=Doe', {\n  decodeDotInKeys: true\n});\nconsole.log(withDots);\n// Output:\n// {\n//  'name.obj': {\n//    first: 'John',\n//    last: 'Doe'\n//  }\n// }\n```\n\nOption `allowEmptyArrays` can be used to allowing empty array values in object\n\n```js\nconst withEmptyArrays = qs.parse('foo[]&bar=baz', { allowEmptyArrays: true });\nconsole.log(withEmptyArrays);\n// Output:\n// {\n//  foo: [],\n//  bar: 'baz'\n// }\n```\n\nOption `duplicates` can be used to change the behavior when duplicate keys are encountered\n\n```js\nconsole.log(qs.parse('foo=bar&foo=baz', { duplicates: 'combine' }));\n// Output:\n// {\n//  foo: ['bar', 'baz']\n// }\n\nconsole.log(qs.parse('foo=bar&foo=baz', { duplicates: 'first' }));\n// Output:\n// {\n//  foo: 'bar'\n// }\n\nconsole.log(qs.parse('foo=bar&foo=baz', { duplicates: 'last' }));\n// Output:\n// {\n//  foo: 'baz'\n// }\n\nconsole.log(qs.parse('foo=bar&foo=baz', { duplicates: 'replace' }));\n// Output:\n// {\n//  foo: 'bar'\n// }\n```\n\nIf you have to deal with legacy browsers or services, there's also support for decoding percent-encoded octets as iso-8859-1:\n\n```js\nconst oldCharset = qs.parse('a=%A7', { charset: 'iso-8859-1' });\nconsole.log(oldCharset);\n// Output:\n// {\n//  a: '§'\n// }\n```\n\nSome services add an initial `utf8=✓` value to forms so that old Internet Explorer versions are more likely to submit the form as utf-8. Additionally, the server can check the value against wrong encodings of the checkmark character and detect that a query string or `application/x-www-form-urlencoded` body was _not_ sent as utf-8, eg. if the form had an `accept-charset` parameter or the containing page had a different character set.\n\n**qs** supports this mechanism via the `charsetSentinel` option. If specified, the `utf8` parameter will be omitted from the returned object. It will be used to switch to `iso-8859-1`/`utf-8` mode depending on how the checkmark is encoded.\n\n**Important**: When you specify both the `charset` option and the `charsetSentinel` option, the `charset` will be overridden when the request contains a `utf8` parameter from which the actual charset can be deduced. In that sense the `charset` will behave as the default charset rather than the authoritative charset.\n\n```js\nconst detectedAsUtf8 = qs.parse('utf8=%E2%9C%93&a=%C3%B8', {\n  charset: 'iso-8859-1',\n  charsetSentinel: true\n});\nconsole.log(detectedAsUtf8);\n// Output:\n// {\n//  a: 'ø'\n// }\n\n// Browsers encode the checkmark as ✓ when submitting as iso-8859-1:\nconst detectedAsIso8859_1 = qs.parse('utf8=%26%2310003%3B&a=%F8', {\n  charset: 'utf-8',\n  charsetSentinel: true\n});\nconsole.log(detectedAsIso8859_1);\n// Output:\n// {\n//  a: 'ø'\n// }\n```\n\nIf you want to decode the `&#...;` syntax to the actual character, you can specify the `interpretNumericEntities` option as well:\n\n```js\nconst detectedAsIso8859_1 = qs.parse('a=%26%239786%3B', {\n  charset: 'iso-8859-1',\n  interpretNumericEntities: true\n});\nconsole.log(detectedAsIso8859_1);\n// Output: {\n//  a: '☺'\n// }\n```\n\nIt also works when the charset has been detected in `charsetSentinel` mode.\n\n### Parsing Arrays\n\n**qs** can also parse arrays using a similar `[]` notation:\n\n```js\nconst withArray = qs.parse('a[]=b&a[]=c');\nconsole.log(withArray);\n// Output:\n// {\n//  a: ['b', 'c']\n// }\n```\n\nYou may specify an index as well:\n\n```js\nconst withIndexes = qs.parse('a[1]=c&a[0]=b');\nconsole.log(withIndexes);\n// Output:\n// {\n//  a: ['b', 'c']\n// }\n```\n\nNote that the only difference between an index in an array and a key in an object is that the value between the brackets must be a number to create an array. When creating arrays with specific indices, **qs** will compact a sparse array to only the existing values preserving their order:\n\n```js\nconst noSparse = qs.parse('a[1]=b&a[15]=c');\nconsole.log(noSparse);\n// Output:\n// {\n//  a: ['b', 'c']\n// }\n```\n\nYou may also use `allowSparse` option to parse sparse arrays:\n\n```js\nconst sparseArray = qs.parse('a[1]=2&a[3]=5', { allowSparse: true });\nconsole.log(sparseArray);\n// Output:\n// {\n//  a: [, '2', , '5']\n// }\n```\n\nNote that an empty string is also a value, and will be preserved:\n\n```js\nconst withEmptyString = qs.parse('a[]=&a[]=b');\nconsole.log(withEmptyString);\n// Output:\n// {\n//  a: ['', 'b']\n// }\n\nconst withIndexedEmptyString = qs.parse('a[0]=b&a[1]=&a[2]=c');\nconsole.log(withIndexedEmptyString);\n// Output:\n// {\n//  a: ['b', '', 'c']\n// }\n```\n\n**qs** will also limit specifying indices in an array to a maximum index of `20`. Any array members with an index of greater than `20` will instead be converted to an object with the index as the key. This is needed to handle cases when someone sent, for example, `a[999999999]` and it will take significant time to iterate over this huge array.\n\n```js\nconst withMaxIndex = qs.parse('a[100]=b');\nconsole.log(withMaxIndex);\n// Output:\n// {\n//  a: {\n//    100: 'b'\n//  }\n// }\n```\n\nThis limit can be overridden by passing an `arrayLimit` option:\n\n```js\nconst withArrayLimit = qs.parse('a[1]=b', { arrayLimit: 0 });\nconsole.log(withArrayLimit);\n// Output:\n// {\n//  a: {\n//    1: 'b'\n//  }\n// }\n```\n\nTo disable array parsing entirely, set `parseArrays` to `false`.\n\n```js\nconst noParsingArrays = qs.parse('a[]=b', { parseArrays: false });\nconsole.log(noParsingArrays);\n// Output:\n// {\n//  a: {\n//    0: 'b'\n//  }\n// }\n```\n\nIf you mix notations, **qs** will merge the two items into an object:\n\n```js\nconst mixedNotation = qs.parse('a[0]=b&a[b]=c');\nconsole.log(mixedNotation);\n// Output:\n// {\n//  a: {\n//    0: 'b',\n//    b: 'c'\n//  }\n// }\n```\n\nYou can also create arrays of objects:\n\n```js\nconst arraysOfObjects = qs.parse('a[][b]=c');\nconsole.log(arraysOfObjects);\n// Output:\n// {\n//  a: [{ b: 'c' }]\n// }\n```\n\nSome people use comma to join array, **qs** can parse it:\n\n```js\nconst arraysOfObjects = qs.parse('a=b,c', { comma: true });\nconsole.log(arraysOfObjects);\n// Output:\n// {\n//  a: ['b', 'c']\n// }\n```\n\n(_this cannot convert nested objects, such as `a={b:1},{c:d}`_)\n\n### Parsing primitive/scalar values (numbers, booleans, null, etc)\n\nBy default, all values are parsed as strings. This behavior will not change and is explained in [issue #91](https://github.com/ljharb/qs/issues/91).\n\n```js\nconst primitiveValues = qs.parse('a=15&b=true&c=null');\nconsole.log(primitiveValues);\n// Output:\n// {\n//  a: '15',\n//  b: 'true',\n//  c: 'null'\n// }\n```\n\nIf you wish to auto-convert values which look like numbers, booleans, and other values into their primitive counterparts, you can use the [query-types Express JS middleware](https://github.com/xpepermint/query-types) which will auto-convert all request query parameters.\n\n### Stringifying\n\n[](#preventEval)\n\n```js\nqs.stringify(object, [options]);\n```\n\nWhen stringifying, **qs** by default URI encodes output. Objects are stringified as you would expect:\n\n```js\nconsole.log(qs.stringify({ a: 'b' }));\n// Output:\n// a=b\n\nconsole.log(qs.stringify({ a: { b: 'c' } }));\n// Output:\n// a%5Bb%5D=c\n```\n\nThis encoding can be disabled by setting the `encode` option to `false`:\n\n```js\nconst unencoded = qs.stringify({ a: { b: 'c' } }, { encode: false });\nconsole.log(unencoded);\n// Output:\n// a[b]=c\n```\n\nEncoding can be disabled for keys by setting the `encodeValuesOnly` option to `true`:\n\n```js\nconst encodedValues = qs.stringify(\n  { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },\n  { encodeValuesOnly: true }\n);\nconsole.log(encodedValues);\n// Output:\n// a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h\n```\n\nThis encoding can also be replaced by a custom encoding method set as `encoder` option:\n\n```js\nconst encoded = qs.stringify(\n  { a: { b: 'c' } },\n  {\n    encoder: function (str) {\n      // Passed in values `a`, `b`, `c`\n      return; // Return encoded string\n    }\n  }\n);\n```\n\n_(Note: the `encoder` option does not apply if `encode` is `false`)_\n\nAnalogue to the `encoder` there is a `decoder` option for `parse` to override decoding of properties and values:\n\n```js\nconst decoded = qs.parse('x=z', {\n  decoder: function (str) {\n    // Passed in values `x`, `z`\n    return; // Return decoded string\n  }\n});\n```\n\nYou can encode keys and values using different logic by using the type argument provided to the encoder:\n\n```js\nconst encoded = qs.stringify(\n  { a: { b: 'c' } },\n  {\n    encoder: function (str, defaultEncoder, charset, type) {\n      if (type === 'key') {\n        return; // Encoded key\n      } else if (type === 'value') {\n        return; // Encoded value\n      }\n    }\n  }\n);\n```\n\nThe type argument is also provided to the decoder:\n\n```js\nconst decoded = qs.parse('x=z', {\n  decoder: function (str, defaultDecoder, charset, type) {\n    if (type === 'key') {\n      return; // Decoded key\n    } else if (type === 'value') {\n      return; // Decoded value\n    }\n  }\n});\n```\n\nExamples beyond this point will be shown as though the output is not URI encoded for clarity. Please note that the return values in these cases _will_ be URI encoded during real usage.\n\nWhen arrays are stringified, they follow the `arrayFormat` option, which defaults to `indices`:\n\n```js\nqs.stringify({ a: ['b', 'c', 'd'] });\n// Output: 'a[0]=b&a[1]=c&a[2]=d'\n```\n\nYou may override this by setting the `indices` option to `false`, or to be more explicit, the `arrayFormat` option to `repeat`:\n\n```js\nqs.stringify({ a: ['b', 'c', 'd'] }, { indices: false });\n// Output: 'a=b&a=c&a=d'\n```\n\nYou may use the `arrayFormat` option to specify the format of the output array:\n\n```js\nqs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' });\n// Output:'a[0]=b&a[1]=c'\nqs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' });\n// Output: 'a[]=b&a[]=c'\nqs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' });\n// Output: 'a=b&a=c'\nqs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'comma' });\n// Output: 'a=b,c'\n```\n\nNote: when using `arrayFormat` set to `'comma'`, you can also pass the `commaRoundTrip` option set to `true` or `false`, to append `[]` on single-item arrays, so that they can round trip through a parse.\n\nWhen objects are stringified, by default they use bracket notation:\n\n```js\nqs.stringify({ a: { b: { c: 'd', e: 'f' } } });\n// Output: 'a[b][c]=d&a[b][e]=f'\n```\n\nYou may override this to use dot notation by setting the `allowDots` option to `true`:\n\n```js\nqs.stringify({ a: { b: { c: 'd', e: 'f' } } }, { allowDots: true });\n// Output: 'a.b.c=d&a.b.e=f'\n```\n\nYou may encode the dot notation in the keys of object with option `encodeDotInKeys` by setting it to `true`: Note: it implies `allowDots`, so `stringify` will error if you set `decodeDotInKeys` to `true`, and `allowDots` to `false`. Caveat: when `encodeValuesOnly` is `true` as well as `encodeDotInKeys`, only dots in keys and nothing else will be encoded.\n\n```js\nqs.stringify(\n  { 'name.obj': { first: 'John', last: 'Doe' } },\n  { allowDots: true, encodeDotInKeys: true }\n);\n// Output: 'name%252Eobj.first=John&name%252Eobj.last=Doe'\n```\n\nYou may allow empty array values by setting the `allowEmptyArrays` option to `true`:\n\n```js\nqs.stringify({ foo: [], bar: 'baz' }, { allowEmptyArrays: true });\n// Output: 'foo[]&bar=baz'\n```\n\nEmpty strings and null values will omit the value, but the equals sign (=) remains in place:\n\n```js\nconsole.log(qs.stringify({ a: '' }));\n// Output:\n// a=\n```\n\nKey with no values (such as an empty object or array) will return nothing:\n\n```js\n// assert.equal(qs.stringify({ a: [] }), '');\n// assert.equal(qs.stringify({ a: {} }), '');\n// assert.equal(qs.stringify({ a: [{}] }), '');\n// assert.equal(qs.stringify({ a: { b: [] } }), '');\n// assert.equal(qs.stringify({ a: { b: {} } }), '');\nconsole.log(qs.stringify({ a: [] }));\n// Output:\n// ''\n\nconsole.log(qs.stringify({ a: {} }));\n// Output:\n// ''\n\nconsole.log(qs.stringify({ a: [{}] }));\n// Output:\n// ''\n\nconsole.log(qs.stringify({ a: { b: [] } }));\n// Output:\n// ''\n\nconsole.log(qs.stringify({ a: { b: {} } }));\n// Output:\n// ''\n```\n\nProperties that are set to `undefined` will be omitted entirely:\n\n```js\nconsole.log(qs.stringify({ a: null, b: undefined }));\n// Output:\n// a=\n```\n\nThe query string may optionally be prepended with a question mark:\n\n```js\nconsole.log(qs.stringify({ a: 'b', c: 'd' }, { addQueryPrefix: true }));\n// Output:\n// ?a=b&c=d\n```\n\nThe delimiter may be overridden with stringify as well:\n\n```js\nconsole.log(qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' }));\n// Output:\n// a=b;c=d\n```\n\nIf you only want to override the serialization of `Date` objects, you can provide a `serializeDate` option:\n\n```js\nconst date = new Date(7);\nconsole.log(qs.stringify({ a: date }));\n// Output:\n// a=1970-01-01T00:00:00.007Z\n\nconsole.log(\n  qs.stringify(\n    { a: date },\n    {\n      serializeDate: function (d) {\n        return d.getTime();\n      }\n    }\n  )\n);\n// Output:\n// a=7\n```\n\nYou may use the `sort` option to affect the order of parameter keys:\n\n```js\nfunction alphabeticalSort(a, b) {\n  return a.localeCompare(b);\n}\nconsole.log(qs.stringify({ a: 'c', z: 'y', b: 'f' }, { sort: alphabeticalSort }));\n// Output:\n// a=c&b=f&z=y\n```\n\nFinally, you can use the `filter` option to restrict which keys will be included in the stringified output. If you pass a function, it will be called for each key to obtain the replacement value. Otherwise, if you pass an array, it will be used to select properties and array indices for stringification:\n\n```js\nfunction filterFunc(prefix, value) {\n  if (prefix == 'b') {\n    // Return an `undefined` value to omit a property.\n    return;\n  }\n  if (prefix == 'e[f]') {\n    return value.getTime();\n  }\n  if (prefix == 'e[g][0]') {\n    return value * 2;\n  }\n  return value;\n}\nqs.stringify({ a: 'b', c: 'd', e: { f: new Date(123), g: [2] } }, { filter: filterFunc });\n// 'a=b&c=d&e[f]=123&e[g][0]=4'\nqs.stringify({ a: 'b', c: 'd', e: 'f' }, { filter: ['a', 'e'] });\n// 'a=b&e=f'\nqs.stringify({ a: ['b', 'c', 'd'], e: 'f' }, { filter: ['a', 0, 2] });\n// 'a[0]=b&a[2]=d'\n```\n\nYou could also use `filter` to inject custom serialization for user defined types. Consider you're working with some api that expects query strings of the format for ranges:\n\n```\nhttps://domain.com/endpoint?range=30...70\n```\n\nFor which you model as:\n\n```js\nclass Range {\n  constructor(from, to) {\n    this.from = from;\n    this.to = to;\n  }\n}\n```\n\nYou could _inject_ a custom serializer to handle values of this type:\n\n```js\nqs.stringify(\n  {\n    range: new Range(30, 70)\n  },\n  {\n    filter: (prefix, value) => {\n      if (value instanceof Range) {\n        return `${value.from}...${value.to}`;\n      }\n      // serialize the usual way\n      return value;\n    }\n  }\n);\n// range=30...70\n```\n\n### Handling of `null` values\n\nBy default, `null` values are treated like empty strings:\n\n```js\nconst withNull = qs.stringify({ a: null, b: '' });\nconsole.log(withNull);\n// Output:\n// a=&b=1\n```\n\nParsing does not distinguish between parameters with and without equal signs. Both are converted to empty strings.\n\n```js\nconst equalsInsensitive = qs.parse('a&b=');\nconsole.log(equalsInsensitive);\n// Output:\n// {\n//  a: '',\n//  b: ''\n// }\n```\n\nTo distinguish between `null` values and empty strings use the `strictNullHandling` flag. In the result string the `null` values have no `=` sign:\n\n```js\nconst strictNull = qs.stringify({ a: null, b: '' }, { strictNullHandling: true });\nconsole.log(strictNull);\n// Output:\n// a&b=\n```\n\nTo parse values without `=` back to `null` use the `strictNullHandling` flag:\n\n```js\nconst parsedStrictNull = qs.parse('a&b=', { strictNullHandling: true });\nconsole.log(parsedStrictNull);\n// Output:\n// {\n//  a: null,\n//  b: ''\n// }\n```\n\nTo completely skip rendering keys with `null` values, use the `skipNulls` flag:\n\n```js\nconst nullsSkipped = qs.stringify({ a: 'b', c: null }, { skipNulls: true });\nconsole.log(nullsSkipped);\n// Output:\n// a=b\n```\n\nIf you're communicating with legacy systems, you can switch to `iso-8859-1` using the `charset` option:\n\n```js\nconst iso = qs.stringify({ æ: 'æ' }, { charset: 'iso-8859-1' });\nconsole.log(iso);\n// Output:\n// %E6=%E6\n```\n\nCharacters that don't exist in `iso-8859-1` will be converted to numeric entities, similar to what browsers do:\n\n```js\nconst numeric = qs.stringify({ a: '☺' }, { charset: 'iso-8859-1' });\nconsole.log(numeric);\n// Output:\n// a=%26%239786%3B\n```\n\nYou can use the `charsetSentinel` option to announce the character by including an `utf8=✓` parameter with the proper encoding if the checkmark, similar to what Ruby on Rails and others do when submitting forms.\n\n```js\nconst sentinel = qs.stringify({ a: '☺' }, { charsetSentinel: true });\nconsole.log(sentinel);\n// Output:\n// utf8=%E2%9C%93&a=%E2%98%BA\n\nconst isoSentinel = qs.stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'iso-8859-1' });\nconsole.log(isoSentinel);\n// Output:\n// utf8=%26%2310003%3B&a=%E6\n```\n\n### Dealing with special character sets\n\nBy default the encoding and decoding of characters is done in `utf-8`, and `iso-8859-1` support is also built in via the `charset` parameter.\n\nIf you wish to encode querystrings to a different character set (i.e. [Shift JIS](https://en.wikipedia.org/wiki/Shift_JIS)) you can use the [`qs-iconv`](https://github.com/martinheidegger/qs-iconv) library:\n\n```js\nimport qsEnvEncoder from 'qs-iconv/encoder';\n\nconst encoder = qsEnvEncoder('shift_jis');\nconst shiftJISEncoded = qs.stringify({ a: 'こんにちは！' }, { encoder: encoder });\nconsole.log(shiftJISEncoded);\n// Output:\n// a=%82%B1%82%F1%82%C9%82%BF%82%CD%81I\n```\n\nThis also works for decoding of query strings:\n\n```js\nimport qsEnvDecoder from 'qs-iconv/decoder';\n\nconst decoder = qsEnvDecoder('shift_jis');\nconst obj = qs.parse('a=%82%B1%82%F1%82%C9%82%BF%82%CD%81I', { decoder: decoder });\n\nconsole.log(obj);\n// Output:\n// {\n//  a: 'こんにちは！'\n// }\n```\n\n### RFC 3986 and RFC 1738 space encoding\n\nRFC3986 used as default option and encodes ' ' to _%20_ which is backward compatible. In the same time, output can be stringified as per RFC1738 with ' ' equal to '+'.\n\n```js\nconsole.log(qs.stringify({ a: 'b c' }));\n// Output:\n// a=b%20c\n\nconsole.log(qs.stringify({ a: 'b c' }, { format: 'RFC3986' }));\n// Output:\n// a=b%20c\n\nconsole.log(qs.stringify({ a: 'b c' }, { format: 'RFC1738' }));\n// Output:\n// a=b+c\n```\n\n## Security\n\nPlease DM [@puruvjdev](https://twitter.com/puruvjdev) if you have a potential security vulnerability to report.\n","readmeFilename":"README.md"}