{"_id":"spiccato","_rev":"38-32b00adbcea5fe0a34ce718201103d00","name":"spiccato","dist-tags":{"beta":"1.0.5-beta","latest":"1.0.0-1"},"versions":{"0.1.0":{"name":"spiccato","version":"0.1.0","license":"MIT","_id":"spiccato@0.1.0","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"f2d916a51803f4ab9ce7760eff18e8ac2fb0fa22","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.0.tgz","fileCount":12,"integrity":"sha512-Pubk5jlnFsgqn3aKvNc7ih9vGhFcion1dhQ5RC0lq3H0jGsQs52lmRjau3fKRb+uLubIfICW9Xb+kimVIEB4JA==","signatures":[{"sig":"MEUCIQCcKrcpHHtNMEYteBTzK/xPv1uVW0oyCvENhf7geueNSwIgCKqzzvXvyooGVcaaZbs+wbepDmRzdK3/eaGSU/xAamE=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70009,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJj/eCOACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmqNsQ//Q4cc8Dfw2hECq2q/r8TwdgOp9K4B5EHd9Fymitt6WGY2MPGC\r\nPupsTh1JGIbeuK3xM8l6/cpibI2uDMu+UnCimBb3E5U3ckUeMzsmbZKQYwkJ\r\nFmUyxEqB3Nx/eKi0g9KvdVb7Ld4k8nJ737DykEcUPsfKgniN5OdOsZjQZp40\r\nWcceeLOcaHMGcgaUSE880ZKa4RGKkBHFrzVJ4rjf4jlM8t+/uGmR4yZsZpl8\r\nq8aPHIPbix2t+cQXKkaAQH7Cx3puWU6u5dC5ZXh+8WVmQZ6nGZa+zoeFj53J\r\n4LRv5lyliEwqWalBlrZrW02HL6Jqax6QyptL5gr0mOsz6P93N6q/Vk6i1d4a\r\nzWJrmlEgAbwHT3/re+tJX42Ms1UAIVJJdsxOwTFzltRRS8KZZMUg8/SGdxSC\r\npwPd32cshjeVDOxgM7Po/f7jfgTsIugjoNi0rWYhb7/JbpySIrwT48x6No5q\r\nLGxMPsWgKy0XovbCwhPPQfNF3JEd8+TrjiTLrBe8NWU+wauORFEUGfxzP23E\r\nq1yN0OYqGNTrFp7T+rAEugp3hpSePXhcOwF9C0+HPfmaoWRm+MxLibNST94Z\r\nvd9EzEXV2sqe7CawgYZr9vBI7dxEhWZEvhVYNFsFXKI3d9wvQbS5SKeFHKV2\r\ns6UDjW33ahKdeHvM4LoK5En7ertwhMEp/3c=\r\n=7RZH\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.0_1677582478127_0.130259107206538","host":"s3://npm-registry-packages"}},"0.1.1":{"name":"spiccato","version":"0.1.1","license":"MIT","_id":"spiccato@0.1.1","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"b3863116e789655282adab932cabf321d4283754","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.1.tgz","fileCount":12,"integrity":"sha512-hiSUnPwRw4f0Vy8MINYjA5g0Lwvjszhy6AqzyxKob9QeqX9PyCQBV92qjNguxEqHbQLBzE5F22ytz8Zqm80jhA==","signatures":[{"sig":"MEUCIQDiTdu0msDAlS+qp3CKijs0jI/uhod6hzonW6EJGZgfLQIgGvkgfGx4IGYO+GAW+NVXLSjfLCgSUqOu6FJSKDVlzeA=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":69944,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJj/ebBACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmojzw//fBT7JL6b7b9XWJcboPc8MWhSI5EcURfrIOC2hK/R1fGHYUfj\r\n5NI3ZTH9JvsOez4To68n45TIHV9Nnl27QfWbbrCDW0611W3nUep4OSWd9Bgs\r\nh/zYcUo4gzntSb1cjPCHpZnOlaeCsXLBdwLUJEemgIcgMl0qC1Jy8UzTF2st\r\ny9V2Ygh4pqdqHf7jO1zEKQqX/JRWwuqp4j8GzvQsjqNcNjtVa5iVtiZgKryv\r\ni4MmXVjZq4UkzVY3IKRjNW+V8fJq5vyFtmTXkWfHrpAIQmry71Txb8tf5VZC\r\n7E0QKSKcESDQewxHmAV9AzFfFlv8C/xTmKf+QHGH2PFTJAwQrB4F1+rbZv0q\r\ndjnGmB+jV52hFskWAqXbP7HSKh5lvw2UmWRQ72tSrjmupufh+kwDJI0XZEIV\r\nQPARnHe5CAlYXPFu/SOJfI3v/urY8dMIQ4KwxZPKRNTCmO4U5z6zqe7TQE6K\r\nCOeVuzmMRscjV79lj60EnuzmNCeMhsY+EpGbQNGj0tYukPB7syKF0AgoO9Yq\r\ntqhHOfEtflYixfdfnQFIPRuGGqQ8imh9maCw+b9jBrH6Q3yEETEz5l69Zax2\r\nU+m+X76PasTmaLmnYjm3xBc15Velh56VlCtsSzR8LvYt6y/YVQDZMn8kkBw1\r\neJKj/dMGgumgUaX6hlWS1ooCm8ifxQ9tEZs=\r\n=YQNx\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.1_1677584064830_0.39418687111300255","host":"s3://npm-registry-packages"}},"0.1.2":{"name":"spiccato","version":"0.1.2","license":"MIT","_id":"spiccato@0.1.2","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"ce3185c538e130cfc043be7ae9d3a3e55e1ee43c","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.2.tgz","fileCount":12,"integrity":"sha512-XIr4IUu6OEmfkSVXijWhOodBIXll3qMlPS+QDJj9kGIkv/tZ1Ko7fNtVCmFzLlNEh8/6HgRrSJkOPpSTPj3Mjw==","signatures":[{"sig":"MEUCIQDkzrbxvCE9CnUY55yYqy+2bOmvoLAbCJj2UY6DIUG8oQIgaKsw4a9UlSyLR+Onl4esxS1mveN9mXaYTBXhHMsA1VM=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70026,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkCGmVACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpfwQ//Vf9umAJCrUI9qNHPqAPHDdcFHhoVuHQuPT2zBeeTzUomXN5u\r\nPGFL/M46GuDDu6njyOykdvdaqKQF3Q7zrIAsBoPX52Pztr3vdnfBof4nXTus\r\nDf2i+/57WD1T2XymwLB5817TCF7txuBWWSYzQLWtxDZUTJcPMpEngue1+VCG\r\nBRfxP12Eu4l1JUe88IowiiwsOeU4NZlacVSwUA97pODVP1lX7L8mBbat4mZ0\r\nDQj96EBcVfkRfycQMTGCNrqBYowFSg/Bgbq40Ezh0FllvGbRnNB+7IxmNXP0\r\nR0oXzGjTQkWpEKEHhTs7IhAXl+Jt5Km3pM3oUqzvfcZQ9y2zHyEYYaJuteTk\r\nyxiffKjc76TfFTQrNOpTyza9O0a+1lUBM03HjB55SWYfVlxbZcHx/zDsLesf\r\n89m/mEWLbrTO5c2GB6GTZmMdCdR9z/jG/74EkDDvoirMf8rRm90XhImSUn7Q\r\nadeU8j9pKzAfjwe+t0SlCBCWjThh/WnQvaje6gO/YZrva8msF8nTwkgDWV7e\r\nT0Pwf8ovGKEDAKOxWQVI00DT8M+LcvHLhaCUE9ZD1kQnGMOQQBNHfkIxr2NP\r\nib/7B9WDS9Zuri72lRsS/0lYRJl8a+WgWji6l4sJK8p26PeihugmJjulJL8K\r\nICg5eDlkQg49KVQfRpsdTf1oswDD++qohIk=\r\n=YLmf\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.2_1678272917545_0.917926943533719","host":"s3://npm-registry-packages"}},"0.1.3":{"name":"spiccato","version":"0.1.3","license":"MIT","_id":"spiccato@0.1.3","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"1bcb2a7118b207a9a0f3523209358f80611fc818","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.3.tgz","fileCount":12,"integrity":"sha512-Mg6DIZXKwx09GcC6oOXlaQ0EaCK5ylc548F1H4Rd09h+/fkqCPi6jUKXeuvQCKvDwuvilZE917W+Ni2GnBqR8g==","signatures":[{"sig":"MEQCIBiYnC2RvpTtdiIjUZnO6SD/JlDC9IRvR40mnHyKhVP6AiBPvQWQz4cq7F6OF8X4iadiYNQ9WRypYPeveIULD98prw==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70402,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkDHUJACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmrX9BAAntTQYr+EuEs2AqGsMDbcqOFDwOc0A2c6gYxliD/ueJoYUA4J\r\nKt+ATwM/b6WM4FPK0OYWf6wI4ku7X5omrLwRxTzSmMGElFNfYjUVp34LKduv\r\nK8xNKt3ja1uAXWIk5dbE4eSl3vEPVBGLV9u22HUFzH9MVuS/zPT0bLahezqG\r\nz6RkieV/NwQT3OXzF5BnM7FRts318ASpLjf94kW+vIIsyxxmenvfZW/5Qp7I\r\nKSm1MEZAWzM2wOS8fSy0xMRtcQcd/GpIPydTP+q8PDFTX+Li5wPo5AVoAAbl\r\nK/ZuC4Ay/U/0Ngs3i4WWP02TMg5Sxa9fZKr4Vl2dfMTKHkfKoPWmKM5ipwbI\r\nkFYMpQwxesbocSA5xeYEeaGhO8iCQtK8w5WK6ztje+OOl/FxCA4xcZL6VEU5\r\nEULtnOnWWdhAd/KuefdUjbKxbTGjD8DmuTYOw/QCDPdlr3BkPj3p0MrS1tcP\r\n96c//63Bq7Mj9SeVC02OEoypGJ7PB1wy+AYlwyH17thSkDMc3FPaZzDddEe5\r\nFnpQqZHF7H1mXRkKXj6MM7VImhlMpxJo4IcobmJaN6EyxKoi6LOrbvzizX4u\r\nrVa1hUYmOdAc1vM7gIka4aFScFOu+DZKz/VQesdHz7js2lpp5wfvh38LdofZ\r\nHiPvpiSD4UZ8YdQf+xdrwBmuY9r9dIsICxc=\r\n=tpIa\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.3_1678537993561_0.45023126161593363","host":"s3://npm-registry-packages"}},"0.1.4":{"name":"spiccato","version":"0.1.4","license":"MIT","_id":"spiccato@0.1.4","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"0804144b143fbcdb00fb9dc429a310e522b41d00","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.4.tgz","fileCount":12,"integrity":"sha512-IdU0zW1VPFgBVVS7/BWiC56kqfO/Bp9eBbdMCFLeoGJHar1JZZ+fRQVQlaxBPObRmug2Yx/La/GkPsUqIECHAQ==","signatures":[{"sig":"MEUCIQC8/sCEbtKLIpv3McBWToKf+rcZqslnhAZc4cvfdZ1UvwIgTl7R8TXaCd4K3mF6whj1ngV/+6qsWy//hpI2KYYreLs=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70553,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkDNi8ACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpnTw//bmBHJMeFYNoD/0AkQbiY4AIHDbVd9HEr6UqOLD2jpkVcLdGv\r\nCJGPUvChhWeznUw/I5XwZunl/Jdm4bpmB/v4WUBQmgtTSS8fhK1Q+ILSBYd4\r\nO/exYmcoi0ZEfzsRz60WQUEYSNPdXRwmDKasVFizurwzwQo4S03PggcDnR81\r\nxzTcVOaAHiD3i0JPlvsdM762LTC6Yepk9fqKOe/1DzobJpHt9pm1LHVXLuYA\r\n1FMQ7v1/8wn/vDKQSJxbibnC+QI0w49nHQVGZN7oF1LV+OOagIQ0KzN6rS4V\r\nChDoKTYcwGs6ePfyeK5j2VDNVmyqcy9f65QW0JL3M3wyoMQuc3jdOzQzWrpm\r\n5SmQ63KXXGTpGt2RnLo2BL7ZEwHuKkMx5MFjDEPZNBjTXDGMLVKDzX/DXkIT\r\n8I3hLbYhdt3xjJURUX+yVVHihuaUQRQMwfi74lgE4aI32Vvn5hH9yl9bn9Vj\r\nAe561+X84fbJ9cznyxZ/PqLBsOdivUmCFYIzCCvREYc+zagQLBBnMn2GRx/K\r\nBt19K8wmV34kFIu/n+kIrrymXrHNUzhrTnJ8R364M47t9DYHkPBbcJpPZJdc\r\nXkUk9YmpsU1FIKX9RawpnXQsiDskiJR1M8zVPq2zOsS36Jiqx3d2Q3nMIZ+g\r\ntbzRb+ZOHPrIp/qUfvpXQHUcziWNiHCUvOE=\r\n=X7K7\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.4_1678563515989_0.705404202951013","host":"s3://npm-registry-packages"}},"0.1.5":{"name":"spiccato","version":"0.1.5","license":"MIT","_id":"spiccato@0.1.5","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"873414924ff376b55e287886244791431b87afad","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.5.tgz","fileCount":12,"integrity":"sha512-Jq1aMQ2JmaXQwiAMWOm7KXfa/y28Kvxvk6nUAkYOhavrVEDuCIohLqmpTHrTwQC0z+e5hIRkPt7U9bYxeVctjQ==","signatures":[{"sig":"MEYCIQCCy6/c2fFwP0xPclHHU4rSKMLBOIt75U1sJzC0FVgM3QIhAIkfbwTKInTK0H0ubvQkTRZf9BdmwsG/pAI9tXmAn5IT","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70564,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkDhfaACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpkJw//Wj6v5yXWB6Bph7gTKSz1guoOesEOxRKPJTm/0V9pUNHqJkx3\r\nFvc8dyYrYR9f4qv80yrgRhJPJ2Nl9dvntku5cXTsEAOdw5s4F05hLEXlQUqJ\r\nKZ4uAc1igXPRQ63/UveKLgcZrWWcNa9ncqoheWj0PeAQKOg5glBnUPdCRsZy\r\nqQVCyBI6AVAFrhv6q6t6WwdXNlxTzhwvxUUcM+Tj+BemKOFmDkYo0/KDKQrz\r\nT/rtxDfu0jYOI6Hd4VtmHsKHi+Xd6SGexq017E4g1ocAWDvXugC/UL+dLVCs\r\nZdFPQmyXz1E5gJhm2uD8S7PROYou77tUfbOJNmsSowN0ldaW5inin9zwqkwV\r\nDZ5Z8CqFDo+DWNQqJ4WItNi5G97lgfwwr2JQvor5bqoza8cpNPR0oQ21sLZz\r\nGdxPC44gHSDlEgSfdUoKvlDtTUPJ1U9rbhUryHYLFdjQazBjLclhx3L+5MXB\r\nugNtW8mpeOTVlh5y+s/7RFpL7mpuJnkx4kLLzpcTd9JQo69hBEwYK41Z+rsn\r\n7a2m1NezLOg9T8DUHjC8RJru4rb8/EjrDodmYH7yRhz8PRFADl9k5NhZvH2E\r\nAc9aCkc2L17MPNXC1s772q6iTbzZp3gAVr47n4etIxrv24WR6GWwgJxQvFBA\r\n+dOyMSd7z/j/pDCE1gIFw6+42GXo2jRXYN8=\r\n=PWh1\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.5_1678645210263_0.3495358317303088","host":"s3://npm-registry-packages"}},"0.1.6":{"name":"spiccato","version":"0.1.6","license":"MIT","_id":"spiccato@0.1.6","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"168ed3d7c61aa457836709e21c095c782978f74d","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.6.tgz","fileCount":12,"integrity":"sha512-nnFVljKaEDzuDdeJsLkI8ZQ9sunaKEQ60RZMYaJMWC6pggIHTLDVU+VCUqGdpxM4TjfQ1rP3Q0fqlsdnHT/9yw==","signatures":[{"sig":"MEQCIHDF5YPmPbWv0AWfwiuAto3oBObsv9HVes9T1oIOJxb0AiBRzqJe1ujc7Zyi9ijfkJh8m/UV+sS4aAg7VCB0dTXYLA==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":70670,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkEZudACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpNNg//codMmf6KhoFa1bWdQ28rW00/La0YcYYB//sFddTWIP0mVJZ1\r\n3ztoM49CJAuVmZbJtcQ1w+ypOrs/RDKcqSM7j5MxmRhXTflbJohjo3Tfg6z/\r\nXDTp0JxMcYE00kY7faUF1gCYEd+0Kg6NwlEdbp0lbo/DmOXQBosPG4dHxM3g\r\npEayaaG+tMTpLMLpjIiI1oyDv2HQ9hemqgSDZGW+7IpEnkTSa7xR8JopL3NZ\r\nVyQqp5qJW72J/1/qoRgFMEACFJX+/GUNNyBGviP6e24s56P2mGXFjRIWmyzF\r\nLNSiGczz6A420NEMUUKl9z5zUBgVx473Vb4/Biq/LSzJmymroqv+WsiJoqj2\r\nKje58+D1TeDWPVw2+2ojqc7lV/CuIyQcSnlKLJWR04Pu/VLiy8DT9mX18eVL\r\noNsJ9HGzLDwGUFh64YKMvJ/OLOmhEeb33wVh1GUDxkQ1JxjpR2bhe3myFuO3\r\nbZsC9YzfeowTasQjJ6X+eP5eTJNqLPPR0jDF+V0dMUOk+M9QFbvsMwRAUoEH\r\neKGJNX2pUkFxpgabixA8UG33qGzFFSxI7gPGRcUEOtcsqGFR8WMx0Oqh5ro6\r\ndJ0WaRKnk5w7mOoVqs7vYXM6URebIBf5P5mMCoiHlY4QaqvjEXkd8hSz1QS5\r\n+VQuIOf5xA1/WoRFbNVZbDHFfkQzIjwBtmw=\r\n=/qdR\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.6_1678875549263_0.32599213145549233","host":"s3://npm-registry-packages"}},"0.1.7":{"name":"spiccato","version":"0.1.7","license":"MIT","_id":"spiccato@0.1.7","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"68da3f3c89bdd8cc54d3e4003ac9b6df2ff07794","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.1.7.tgz","fileCount":12,"integrity":"sha512-dPlOH28HcG3+UNiMvkVIY2j1zpI2zm6lKLsLUf5DJx+7V3HyIFq/vtWmTP25MjeYHAl2Mvr4lJknjiWnSfbpgw==","signatures":[{"sig":"MEQCIHxAwz/8JC46sFqn/X+25Y4ghrFIYhDcTE5wBXhojBpRAiBuKVQqXb8BF7+B//3q372OBiBkJBaZMYJfyPoXxLMUkA==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":72966,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJkFYZgACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmoRgg//TR5chnVlrGdfOXcyoxrr+VBE8ftGK45WzrPoWbm7SAS+2ice\r\nXfxxEw29dE1B0V6cVKT0YBtEhmX3Kq0vkUiMjVqhTnAnaChm2pEviDrp/bbl\r\nFXv93awNooHM/bReIfgnPFyT18ZJ7fICUhCEf3uo2G3j+6JKfodDI3fRxOIX\r\nIq9WHPsVIm3Uf1bBYG+yCZBX0K/mm7sr79xwJS0/iS8otJ+FzJ79qOgm2Xnc\r\n5zW3/Uqgcy+g9QP3PoOddouiqzyLKeN+44mDCujnOFr7udWOPesbY7SEOm6q\r\ne9uFVoQpUIeMioJ7qfh5C5kYLLKA9nrpVBjbg0wa4IDU5eEIikE9aj2ulUCh\r\n8vH2DSgjoF4FymHQUHBcYW0ac6XII5OO0XiKaWvDlwVqcBEhBzL8k8uIEkZh\r\n0+9qu++6NiXsY2qO7IkRq6EKaGAZ4Fcc8MBQSuL0ha1vPzKkfh7Xb0NTHq9V\r\n0cZX8dJTQPdMp+nDciS8xPto122/+yBr8YmtHiIYkK9Xt3ih8EMTeO7vmahC\r\nUQN8s3N/UJdcSA5fgYoinumiCORUKkohnelzvG6yLJ/DbpgWBW9+/HlcXH56\r\ngTCn4DwfHDjk8cXKK+GikDN5mxigvSu7W3Taxf1S7WkiaHEvdOGUSWdEdalM\r\nreE9eJ+jDXTRPC9Yf+FkwsgF/cjCdFd0xyo=\r\n=urkE\r\n-----END PGP SIGNATURE-----\r\n"},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.1.7_1679132255985_0.9491019525315969","host":"s3://npm-registry-packages"}},"0.2.0":{"name":"spiccato","version":"0.2.0","license":"MIT","_id":"spiccato@0.2.0","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"5f66f9965d606e4946fc7346a759ba04b03be674","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.0.tgz","fileCount":12,"integrity":"sha512-sf7/AxuJW4oKFqljkZKTXw1vRwWBU2mK4xHqZBY3f/12UNEk1bXP2o96r2KtD9oM+W7Nu+S+Yykaupdkh+FtTA==","signatures":[{"sig":"MEQCIBTl1A13i3kJvJy31c/+5bfzyeKju1k1bgHB71QqVXAfAiBi5Lsf4iad//AOc3haA4G8irclejDX4+kKcpCx902cNw==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":73914},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.0_1684316690874_0.3619809777439307","host":"s3://npm-registry-packages"}},"0.2.1":{"name":"spiccato","version":"0.2.1","license":"MIT","_id":"spiccato@0.2.1","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"22220db0875134fe0f068635f180194d77f89bd4","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.1.tgz","fileCount":12,"integrity":"sha512-2Wz0gcy2Lxc45wv71t2jBZv/fh9418rb+0Qtx3gMST2N9Xnsqz1L3tYAHIEjBRuEHSafQSuDGQXHIpjWEh8NMw==","signatures":[{"sig":"MEUCIQCgxAGPgK9PzblxYLJgTvjYI8BOneVbWmxW+0ONb4+ONQIgSWJfmGbjNFbLk8/8euji5129+t5iC6hCcoJs9jbX2HE=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":75470},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.1_1684407457141_0.18241158102797095","host":"s3://npm-registry-packages"}},"0.2.2":{"name":"spiccato","version":"0.2.2","license":"MIT","_id":"spiccato@0.2.2","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"15428b076d656313c02ac78e4aa528f6c3370d52","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.2.tgz","fileCount":12,"integrity":"sha512-vPYmtcV5JzH1Gb7HCK5oYH0OzOYMMhHxaZQlpBCxY8HWNSKYUrgylQOpfZmOYpJWu+ycBeW47bROy3Yn3wTksg==","signatures":[{"sig":"MEYCIQC6tarNsKAVyjZYGR8KK2JGljx6OPe4dnFkXM8r1II3IQIhAOHVtlyweoO552NwX2J4J97HyuhqJgYR5+2gTR5ZH+5b","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":78365},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.2_1684493123321_0.9332710352414872","host":"s3://npm-registry-packages"}},"0.2.3":{"name":"spiccato","version":"0.2.3","license":"MIT","_id":"spiccato@0.2.3","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"9ae48d005ee6a499e71950e07719418f8ed4aa72","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.3.tgz","fileCount":12,"integrity":"sha512-puU2EQf/xdDOA9+Npwbv+qNssht1xPC0JLjj4FXoe0iQc+Z+GFP6MIUKJ723jE0qYis/kpSddWfmzpcKFPRgsA==","signatures":[{"sig":"MEYCIQCpzyRsz+LqrcQOhUWvSMazFkMFgs2z2fWVpi8so3DCRgIhAIqkyklgQH77w9HtMA3bSOV5eB75EwJi+z9pddmQhRLP","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":81520},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.3_1684749107068_0.10347023902969266","host":"s3://npm-registry-packages"}},"0.2.4":{"name":"spiccato","version":"0.2.4","license":"MIT","_id":"spiccato@0.2.4","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"c2b57c9134b9e7aec2980b958ca78486a77f16bb","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.4.tgz","fileCount":12,"integrity":"sha512-sNUP6/2eQUh52kJDYRjZWNhk5SrPPmYlrQ2QkTgRKbkYdZ2BZb+IwnG5v/j/Y4q3O24MhE6SBoX0T4+BrHsYGw==","signatures":[{"sig":"MEUCIEPIDYnV3FxJo4s/eSL/BV0UI1I2So4j+mfSVHws/bfvAiEA16bNxPFPOYDFXtDXukf3oB028xi0oJpiw4BRuk9N7sY=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":81979},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.4_1684750643845_0.5676813821745776","host":"s3://npm-registry-packages"}},"0.2.5":{"name":"spiccato","version":"0.2.5","license":"MIT","_id":"spiccato@0.2.5","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"8d2075583b8b8a4c75e38ad170427604111a5304","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.5.tgz","fileCount":12,"integrity":"sha512-kqbcvVud+3zMVIRz0lcHOmDgdUBll56c7ggagJQrbhz2H9y/nyYSmL+FBq6ph2DxRU4q1Lefk7j/oThvt4m1Jg==","signatures":[{"sig":"MEYCIQDxbqHR2dMk6KXzuIRui15SMBfHnGw1qRrCe5Tn8RYjhgIhALAw8DTPO6XJZUfFSGqjKJjVXMaUsQU1TK8CCzS3b8/A","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":82004},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.5_1684922166805_0.8670892648024826","host":"s3://npm-registry-packages"}},"0.2.6":{"name":"spiccato","version":"0.2.6","license":"MIT","_id":"spiccato@0.2.6","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"390daae855cbd496a57892de7ab90102917700e7","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.6.tgz","fileCount":12,"integrity":"sha512-jfdXHJuQlvTzUsKEofrF8fhAaDSz8F/cVhlgmbiRPS73SRWlUqDnxXCdBlrnr+LTIJpL0vnDznKhXDjLzEm9Yg==","signatures":[{"sig":"MEUCIAfu0bimJTh6d9Twc5Uz7WOWbQ6sKs+CItljx2mpu/slAiEAjfb+OXIL4YZ/cOd2xL6ZER81EBdhLfTPEGLULDOFl6s=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":83303},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.6_1685007502200_0.06016069257865375","host":"s3://npm-registry-packages"}},"0.2.7":{"name":"spiccato","version":"0.2.7","license":"MIT","_id":"spiccato@0.2.7","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"46e3a6b341aa9527e005c1f0fd9732862f7a7b44","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.7.tgz","fileCount":12,"integrity":"sha512-TsRWZSHmw4o8f4bitI8nWxp4lQ6rXUY+aOs1GLICgPy3ESkVrHkSkm/RtRdyJK48kHmGYN3oioHIzz5CZHi9vw==","signatures":[{"sig":"MEUCIERyblN7X3PIj2ga+MQudNEnTrvqBgHqSrusoLAYdcKvAiEA8rRNa+4/0FE8RajPGxeJfRQPQrHZs2j4bfatWey/FUM=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":83603},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.7_1685008836485_0.08852229598094397","host":"s3://npm-registry-packages"}},"0.2.8":{"name":"spiccato","version":"0.2.8","license":"MIT","_id":"spiccato@0.2.8","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"1bb272c3d2d1c5d397b95f71d5fc573a200764fb","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.2.8.tgz","fileCount":12,"integrity":"sha512-F543X/ijj8zVBKbCgS+6BOjglvMxeSu8AELAZM6CWTRgntB0RZOU2rHDrAlqaryVObq6aa0J1nia0J8YlLMRRw==","signatures":[{"sig":"MEYCIQCHrHDEm2CL2aMO53lzoqBr8xGDUa5XGht7hUh6JmtLtAIhAPoZC97p7I1YESc7tQ1iGG9icvcR+XyFDjXlBGV3rQ/z","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":83635},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.2.8_1685009680555_0.40235632272351074","host":"s3://npm-registry-packages"}},"0.3.0":{"name":"spiccato","version":"0.3.0","license":"MIT","_id":"spiccato@0.3.0","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"0649563408da314825ffb00a48fb42163f180289","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.3.0.tgz","fileCount":12,"integrity":"sha512-AQ+dmqNMybKWBpMRnLPG8w7OcXPs9SmjR5xkYGRlb8pbeLYu7dbUkdDOdY0ZcJiN+/cPP2ov696f+ITPXdtg6w==","signatures":[{"sig":"MEUCIEt2MYIUweIoOjppoD6BuyR+7pREf9nM0lPheDyuRuoAAiEAvsf5wAOt96Q7Pc2s8YLzu5ZMwNYIJb7Jl55qrhnQ4+g=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":85340},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.3.0_1685354474763_0.943803663318771","host":"s3://npm-registry-packages"}},"0.3.1":{"name":"spiccato","version":"0.3.1","license":"MIT","_id":"spiccato@0.3.1","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"a00e1df761b1a11d674caad180f8ff2ac7265048","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.3.1.tgz","fileCount":12,"integrity":"sha512-uyC/cn45RL0Dq+pxWoxvWfLbe3xQZm+XrddlRfk4bgrcXEAbPvGJf9O/bwXMiYh9vxaXpa8eK/X6lkmrRb9eRA==","signatures":[{"sig":"MEUCIQCgWNDtByK6K1ZtvABsFM6slik+CO4BFZOQinpFgrkjZQIgTbQBgvDqWqjxnqvETQs+GEcowpEjPjsUEmeMt+zTNm0=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":86413},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.3.1_1686044377241_0.9711746797573562","host":"s3://npm-registry-packages"}},"0.3.2":{"name":"spiccato","version":"0.3.2","license":"MIT","_id":"spiccato@0.3.2","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"70f45c32bee3c65c047cedbd9a4e6ad927fa199d","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.3.2.tgz","fileCount":12,"integrity":"sha512-ut3RrIXUcWz6KhkSI9s7185dGR+Glp7Ex+hts25MAQgJAI4IKaCSsNOzZrdzqOQ+XAmy7RXF1HLc5hEX6Pi1Hg==","signatures":[{"sig":"MEYCIQDh79cKwhVeavW/HnFKhyV/zNJpYG2eZSvjVemotZVVmgIhAIcp0312Y/d8GA0n4Jjyu5j4E6vB3Db5lq8a3mU4taL2","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":86413},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.3.2_1688725530066_0.7061868589479192","host":"s3://npm-registry-packages"}},"0.3.3":{"name":"spiccato","version":"0.3.3","license":"MIT","_id":"spiccato@0.3.3","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"4a1252859b867ae9124482cc84df81f25954d9dd","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-0.3.3.tgz","fileCount":12,"integrity":"sha512-SWRMf7wllDiyUcMUqovjKQfAJK7htPkx8t2Bu3MZDyTrSGaNSOSeeAcA+7ytpZQEuhoP8lY+bEWqXG3pIBtn5g==","signatures":[{"sig":"MEUCIBodPoq4BNGrgArZobL6UNM17jCufd8XQhHadk/cdIawAiEAs6X78tjQGYFQNho9kZzgA0oHPJ0Urvp8kdYAD6ziYF8=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":87786},"main":"index.js","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"6.14.16","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"14.19.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^4.9.4","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_0.3.3_1691486547525_0.796298516961069","host":"s3://npm-registry-packages"}},"1.0.0-beta":{"name":"spiccato","version":"1.0.0-beta","license":"MIT","_id":"spiccato@1.0.0-beta","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"3f9f1b766c0141d25277394605934bc926cb4a04","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.0-beta.tgz","fileCount":12,"integrity":"sha512-ZjZKGJXhkV2iKOxgFbEocnwKLKcDNadNIrKY3dpnKobcbHpwn8cqdpcrCMVKcjwrta/XrPPdfag+n1lX/wfNLg==","signatures":[{"sig":"MEUCIQD5pBZUI4PFCHTmkpO9aWZDGZd20Wk1rBob/Qd0tfuOgQIgJXNoQUuIdIGtgyIBLu672GiRnjhFhE3Ep4V7jSYODeg=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":93046},"main":"index.js","types":"./index.d.ts","gitHead":"4acdaacb6a95869e6f33ac84717af92669a6cee0","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.0-beta_1721236360289_0.4015100845012649","host":"s3://npm-registry-packages"}},"1.0.1-beta.1":{"name":"spiccato","version":"1.0.1-beta.1","license":"MIT","_id":"spiccato@1.0.1-beta.1","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"8e6b2ad6b95729161ee1d0f0696f5697c2612761","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.1-beta.1.tgz","fileCount":12,"integrity":"sha512-TzP2o5ykdZT8wIQDCxwvfRrI7A3XlPyUCwjcEd9nMFxs5EKqHT1Ag6YtTNLzS7OWHEj9G3Eu9fnDl78FKYtKjw==","signatures":[{"sig":"MEQCIAO/BgxaTaJl7EbgCeQmwpqSgeqGQMAXspp0+QJyPCEuAiAY6X7ZEbm1opxQGTr+OCArSwXm1uVRnSbq5TPohyrkAw==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":105895},"main":"index.js","types":"./index.d.ts","gitHead":"8ba5b238ac1534e24e167ade51e3c009ff7e589f","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.1-beta.1_1721384048313_0.3194133770501075","host":"s3://npm-registry-packages"}},"1.0.2-beta":{"name":"spiccato","version":"1.0.2-beta","license":"MIT","_id":"spiccato@1.0.2-beta","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"69f2ff2873d5e702d99fe09b711932f24a69e94a","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.2-beta.tgz","fileCount":12,"integrity":"sha512-mkpZBXT7O82B1NuPFiM0bXOJQg0fZq5XGK2wup163ZCBYzkj3JO52i8pTcOZ5hcqGURhq9beOBjECcGr7Y8y9w==","signatures":[{"sig":"MEUCIQCi/ulDTxFRjIbKtvsmFRBCGQvjvhMjF4tNuE4F9B43IQIgea9h/Wcv1nQZq7M/wd3wUSP4vd14701+dHYPXF1b/gg=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":105815},"main":"index.js","types":"./index.d.ts","gitHead":"745987f102f59bda42eff1472a43df0b552e8ee2","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.1.0","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"20.9.0","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.2-beta_1721440216240_0.4384774195764487","host":"s3://npm-registry-packages"}},"1.0.3-beta":{"name":"spiccato","version":"1.0.3-beta","license":"MIT","_id":"spiccato@1.0.3-beta","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"d8b25247fd37a11d5ec0b272a39cbf80242472dc","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.3-beta.tgz","fileCount":12,"integrity":"sha512-d75GHyLw4TvykFSPenQBYX1uh+hRoL9FECfD90dMAhssy0o1zamfNC9RpQKoLyKg1PbvXoqY67rgY2t1HDe9Ig==","signatures":[{"sig":"MEUCIQCHxBJsvkN4ouJka5Ke1ESUD6dNcPcWToLwDQMbI43vwwIgRrYdaGnDWQT8DbHrIAgzYu2e3MWEWjVMD6UgGgAx/yY=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":106502},"main":"index.js","types":"./index.d.ts","gitHead":"b75104c8d9f4f2e9fb5004cc5e0212727eac54b6","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.3-beta_1721556904534_0.6927183684500844","host":"s3://npm-registry-packages"}},"1.0.4-beta":{"name":"spiccato","version":"1.0.4-beta","license":"MIT","_id":"spiccato@1.0.4-beta","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"6e94deb5528762dca26cdfb0da3e398bf93e8833","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.4-beta.tgz","fileCount":12,"integrity":"sha512-9Cvt/6fZa2WaC+M5ouye3s3OzE5HIMmHNoSUbvjzEMlxmGiceOeiANObPnRBiQQ+xqsoZRkV91uS+w2M7hmcoA==","signatures":[{"sig":"MEUCIQDtDPnOLZsvC64i0sqQv+oxpQtU1E8DBoDDZKmDmfcSqAIgKz5a1on82zIwgofNl5c8/W94iZsIM/fkhk5eXJ9A51w=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":110572},"main":"index.js","types":"./index.d.ts","gitHead":"cc06f2b54af181a77d180b851280e7bfb36d434a","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.4-beta_1721644261567_0.7213483572271726","host":"s3://npm-registry-packages"}},"1.0.4-beta.1":{"name":"spiccato","version":"1.0.4-beta.1","license":"MIT","_id":"spiccato@1.0.4-beta.1","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"9c73fe7b355e0642f634d2d70c23181430b7e5de","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.4-beta.1.tgz","fileCount":12,"integrity":"sha512-3/nMa9avNxPJa1UEXUiGRwOm2Q/ZUDZ0hK8QvsJj5atzqE4qAI9Np9J4NOQbe7huFfV/9CUktzUmKZibiIr7qA==","signatures":[{"sig":"MEYCIQDuT/ZRQu/xT1wyzu1VSeDQSZqtSGI+I7OAbD8H8CL6wAIhANvQK/x+91Tn6PLJH1xtaTqPWP/LNse1oVYeIWj4J3SX","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":110672},"main":"index.js","types":"./index.d.ts","gitHead":"cc06f2b54af181a77d180b851280e7bfb36d434a","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.4-beta.1_1721644623197_0.4228673564151426","host":"s3://npm-registry-packages"}},"1.0.4-beta.3":{"name":"spiccato","version":"1.0.4-beta.3","license":"MIT","_id":"spiccato@1.0.4-beta.3","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"d6dfb1461ad5a5ee825522e22ac99af61b3fc0fe","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.4-beta.3.tgz","fileCount":12,"integrity":"sha512-ttcbo9vLT5iyt2GD1dZV6Ka5ozPlWgd5/Xn7qsm22IR1QiOnjSTOeRPzUyHAoIMo34GDbZ59evjU4VuFO/FZxA==","signatures":[{"sig":"MEYCIQDXw4ELapRJg5FSCa+J/rHYYBviVoe0XqN0q0KJSvbuMQIhAKQEAcVC1YEmCsFZk3xUBNmxE4HA1cy8o+fGlvJh16AN","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":110824},"main":"index.js","types":"./index.d.ts","gitHead":"65a133bce26b99e366f2c4b75b6be88b402a34ab","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.4-beta.3_1721646269118_0.7050745064381307","host":"s3://npm-registry-packages"}},"1.0.5-beta":{"name":"spiccato","version":"1.0.5-beta","license":"MIT","_id":"spiccato@1.0.5-beta","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"7f67a9ad4c469d27ba24fbe1e9f8eb23a7b358f8","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.5-beta.tgz","fileCount":12,"integrity":"sha512-nRTrdspd4R5MjBUM99+fmyyrKor8KlkKPS7QzAc8LYfFxZ2qQr+9HtTnBcqy1vaMi09Pc9sXzGKxoDoDdGL3fA==","signatures":[{"sig":"MEYCIQDRnxHilkEyEVbkXneFl8y8UZIVzg3ez4aum/N4qupzOgIhAJzJBER43R+Vg4/pT+NA/WqF7vwm4VJ4AcIWNqrOMzXo","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":111697},"main":"index.js","types":"./index.d.ts","gitHead":"152344d18e4b152cb10eaea666ff60ebdeecd0a2","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.5-beta_1721725953314_0.25675387930381843","host":"s3://npm-registry-packages"}},"1.0.0":{"name":"spiccato","version":"1.0.0","license":"MIT","_id":"spiccato@1.0.0","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"dist":{"shasum":"c0f2933ecec17b15b9a77d4dac44ca37f599786f","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.0.tgz","fileCount":12,"integrity":"sha512-p6LKGS5LkLdzJ9y5rC6JpQk6ErLm7uKhIk0VEfc2Gk1TMbm4GZusDOoj8yj2VnEk07ZY27sLFBbtXSmS99gJ7Q==","signatures":[{"sig":"MEYCIQCuZFkKmi3HucfWhR0jINSHYvpwnXGarddhTR0++Oz0UwIhAIE2Zq0IsJKXVpdHsnNgcFVhqPwPKB7hwwWtgYXEOHxl","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":111692},"main":"index.js","types":"./index.d.ts","gitHead":"eec2fe87f31ba5cbf9fa94b871910bc647537281","scripts":{"test":"npm run build && ./node_modules/.bin/jest","build":"./scripts/build.sh","start":"npx tsc; node index.js"},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"_npmVersion":"10.2.4","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","directories":{},"_nodeVersion":"21.6.1","_hasShrinkwrap":false,"devDependencies":{"jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5","@types/jest":"^29.2.4"},"_npmOperationalInternal":{"tmp":"tmp/spiccato_1.0.0_1725325681274_0.17097805373471808","host":"s3://npm-registry-packages"}},"1.0.0-1":{"name":"spiccato","version":"1.0.0-1","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","license":"MIT","main":"index.js","devDependencies":{"@types/jest":"^29.2.4","jest":"^29.3.1","ts-jest":"^29.0.3","typescript":"^5.5"},"scripts":{"start":"npx tsc; node index.js","build":"./scripts/build.sh","test":"npm run build && ./node_modules/.bin/jest"},"_id":"spiccato@1.0.0-1","gitHead":"50da4b330ca7247110ba6f70d647904f8e0337ba","types":"./index.d.ts","_nodeVersion":"21.6.1","_npmVersion":"10.2.4","dist":{"integrity":"sha512-WCulBJyyhOXh2HK6mC7okWCDqU269KV/FT7AYScjDZShkEPuPBHCCoEUQIUgdjzAs8zw8V/mLwfw6ySqGZOwuQ==","shasum":"1d5eb15d5e097c51637cdc17b809a3b1dfe298a6","tarball":"https://registry.npmjs.org/spiccato/-/spiccato-1.0.0-1.tgz","fileCount":12,"unpackedSize":111236,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIHB4TfsWZsa9uh76fOHnv6nnuzFAMXnFQDJMzgO96f1pAiBw1BV8GnvBGddO19Y1iA6xn6J6jJkTUwiiCII51puFHw=="}]},"_npmUser":{"name":"qdizon","email":"qdizon@gmail.com"},"directories":{},"maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/spiccato_1.0.0-1_1725326442565_0.27624885891678663"},"_hasShrinkwrap":false}},"time":{"created":"2023-02-28T11:07:58.127Z","modified":"2024-09-03T01:20:42.904Z","0.0.1":"2023-02-22T11:35:18.410Z","0.0.2":"2023-02-22T11:40:23.634Z","0.0.3":"2023-02-23T11:18:25.698Z","0.1.0":"2023-02-28T11:07:58.299Z","0.1.1":"2023-02-28T11:34:25.024Z","0.1.2":"2023-03-08T10:55:17.676Z","0.1.3":"2023-03-11T12:33:13.799Z","0.1.4":"2023-03-11T19:38:36.162Z","0.1.5":"2023-03-12T18:20:10.426Z","0.1.6":"2023-03-15T10:19:09.422Z","0.1.7":"2023-03-18T09:37:36.145Z","0.2.0":"2023-05-17T09:44:51.027Z","0.2.1":"2023-05-18T10:57:37.330Z","0.2.2":"2023-05-19T10:45:23.537Z","0.2.3":"2023-05-22T09:51:47.250Z","0.2.4":"2023-05-22T10:17:24.015Z","0.2.5":"2023-05-24T09:56:07.051Z","0.2.6":"2023-05-25T09:38:22.352Z","0.2.7":"2023-05-25T10:00:36.779Z","0.2.8":"2023-05-25T10:14:40.755Z","0.3.0":"2023-05-29T10:01:14.951Z","0.3.1":"2023-06-06T09:39:37.464Z","0.3.2":"2023-07-07T10:25:30.250Z","0.3.3":"2023-08-08T09:22:27.701Z","1.0.0-beta":"2024-07-17T17:12:40.506Z","1.0.1-beta":"2024-07-19T10:03:40.143Z","1.0.1-beta.1":"2024-07-19T10:14:08.493Z","1.0.2-beta":"2024-07-20T01:50:16.447Z","1.0.3-beta":"2024-07-21T10:15:04.725Z","1.0.4-beta":"2024-07-22T10:31:01.745Z","1.0.4-beta.1":"2024-07-22T10:37:03.376Z","1.0.4-beta.2":"2024-07-22T11:01:39.262Z","1.0.4-beta.3":"2024-07-22T11:04:29.251Z","1.0.5-beta":"2024-07-23T09:12:33.476Z","1.0.0":"2024-09-03T01:08:01.451Z","1.0.0-1":"2024-09-03T01:20:42.724Z"},"license":"MIT","description":"A general purpose state management library that provides high level automation of common state management tasks and is easily extendible and customizable.","maintainers":[{"name":"qdizon","email":"qdizon@gmail.com"}],"readme":"# Spiccato \n\n`Spiccato` is a simple, lightweight, and efficient state management library built for both browser and backend applications. It automates several common state management patterns, is easily extendible and customizable, and makes typically complex tasks like state persistence simple to implement. It is written in typescript and has no dependencies. \n\n## Index\n- [Installation](#installation)\n- [Basic Usage](#basic-usage)\n    - [setState](#setstate)\n        - [Object Input](#object-input)\n        - [Function Input](#function-input)\n        - [Asynchronous Behavior & Callback Argument](#asynchronous-behavior--callback-argument)\n        - [updatedPaths & More Efficient Updating](#updatedpaths--more-efficient-updating)\n    - [Initialization Options](#initialization-options)\n    - [Project Wide State Management](#project-wide-state-management)\n    - [State Schema](#state-schema)\n    - [State Accessors](#state-accessors)\n        - [Immutable Access](#immutable-access)\n        - [Dynamic Accessors](#dynamic-accessors)\n        - [When to Use Dynamic Accessors](#when-to-use-dynamic-accessors)\n    - [Customization](#customization)\n        - [addCustomGetters](#addcustomgetters)\n        - [addCustomSetters](#addcustomsetters)\n        - [addCustomMethods](#addcustommethods)\n        - [addNamespacedMethod](#addnamespacedmethods)\n        - [Customization Chaining](#customization-chaining)\n        - [Performance Implications & setStateUnsafe](#performance-implications--setstateunsafe)\n    - [Events](#events)\n        - [addEventListener](#addeventlistener)\n        - [Event Payload](#event-payload)\n        - [removeEventListener](#removeeventlistener)\n    - [Errors](#errors)\n    - [Static Methods](#static-methods)\n- [Typescript Support (improved in v^1.0.0)](#typescript-support)\n    - [Introduction](#introduction)\n    - [Basic Instantiation patterns in Typescript](#basic-instantiation-patterns-in-typescript)\n    - [Advanced Instantiation Patterns In Typescript](#advanced-instantiation-patterns-in-typescript)\n    - [Typing Your State Schema](#typing-your-state-schema)\n    - [Type Exports](#type-exports)\n- [Connect To Local Storage](#connect-to-local-storage)\n    - [LocalStorage Concepts](#localstorage-concepts)\n    - [Basic Usage](#basic-usage-1)\n    - [Storage Options](#storage-options)\n    - [State Persistence](#state-persistence)\n    - [Inter window Communication](#inter-window-communication)\n        - [windowManager](#windowmanager)\n- [Command Line Interface](#command-line-interface)  \n    - [package.json Script](#packagejson-script)  \n    - [Keyword Arguments & File Structure](#keyword-arguments--file-structure)  \n    - [CLI Flags & Options](#cli-flags--options)  \n    - [Support File Flags](#support-file-flags)  \n    - [Changing Default Names](#changing-default-names)  \n---\n## Installation\n\n```\nnpm i spiccato \n```\n\n## Basic Usage\n\nCreating a new state manager is accomplished in two simple steps. \n\n1. **Define a State Schema**: State schemas are the default values for a state object. It contains all key value pairs that are expected to exist over the lifetime of the manager. \n2. **Initialize a StateManager instance**: Pass the defined state schema to the `Spiccato` constructor call. \n\n```javascript\nimport Spiccato from 'spiccato';\n\n// Defined State Schema\nconst stateSchema = {\n    num: 1,\n    str: \"Hello, world!\"\n}\n\n// Pass the schema to the initialization of the instance\nconst manager = new Spiccato(stateSchema, {id: \"myState\"})\nmanager.init()\n\nconsole.log(manager.state.num) // 1\nmanager.setState({num: 2})\nconsole.log(manager.state.num) // 2 \nmanager.setters.setNum(5) // dynamic setter\nconsole.log(manager.getters.getNum()) // => 5; dynamic getter\n```\n#### **setState**\n\n`setState` is a low level method the you can access on your `spiccato` instance. It can be used to set all properties of an associated state, but more commonly just a subset of properties. This method accepts three arguments:\n\n| Argument | Type(s) | Description |\n| --- | --- | --- |\n| updater | object \\| function | This can be either an object or a function which returns an object. In either case, this object will be used to update the values of your state. |\n| callback | function \\| null | a callback that is executed *after* a state update has been performed. |\n| updatedPaths | string[][] \\| null | Defines what paths in your state are being updated. |\n\n##### **Object Input**\n\nWhen an object is passed, the state will update just the properties indicated in the object without modifying/removing any of the other properties in the state. However, be cautious when using an object to update nested structures. You will need to make sure that every call to `setState` updates every property in the nested structure or else the fundamental structure will change. In situations like this, it is better to use a `function` as an input (see below), or a [dynamic nested setter](#dynamic-accessors).\n\n```javascript\nconst stateSchema = {\n    someBool: true,\n    user: {\n        name: \"\",\n        address: \"\",\n        phone: \"\",\n    }\n}\n\nconst manager = new Spiccato(stateSchema, {id: \"setStateDemo\"})\nmanager.init()\n\n// this is fine and doesn't change any other state\nmanager.setState({someBool: false}) \n\n// This is also fine because it sets all the defined properties of the nested object\nmanager.setState({user: {name: \"John Doe\", address: \"123 Main st\", phone: \"555-5555\"}})\n\n// Watch out here! This fundamentally changes the state schema because it only sets some properties of the nested state\nmanager.setState({user: {name: \"Jane Doe\"}})\nconsole.log(manager.state.user) // => {name: \"Jane Doe\"}; address and phone properties are gone.\n```\n\n##### **Function Input**\nAs described above, object inputs to `setState` have some drawbacks when working with more complex state values like *objects* and *arrays*. In these situations, it is recommended that you use a function as the initial input. This function will receive one argument, which is the `state` at the time the function is called. The return value can either be an object with the necessary updated values, or an array of two elements where the first is the object with updated values and the second is an array indicating what paths have been updated. Like the object input, values in the returned object from this function are updated, and anything omitted is not updated. \n\n```javascript\nconst stateSchema = {\n    someBool: true,\n    user: {\n        name: \"\",\n        address: \"\",\n        phone: \"\",\n    }\n}\n\nconst manager = new Spiccato(stateSchema, {id: \"setStateWithFunction\"})\nmanager.init()\n\nmanager.setState(function(prevState){\n    return {someBool: !prevState.someBool} // returns just an object\n})\n\nmanager.setState(function(prevState){\n    return [ \n        {user: {...prevState.user, name: \"John Doe\"}}, // updater object\n        [manager.paths.user.name] // paths that have been updated\n    ];\n})\n```\nIn this example, we call `setState` twice, each time with a function as an argument. In the first call, we take a boolean value and return its inverse. This could also be accomplished with an object input, but you would then have to access the boolean value outside the set state call so you could determine its inverse. \n\nIn the second call, we take the more complex *user* object and set just a subset of its nested values. With `...prevState.user`, we are effectively creating a new user object with all the same properties as the incoming state's user object. We then change just the *name* parameter in this new object we have created. This way we are sure that we have completely preserved all the parameters we haven't touched in the *user* object. As a second element in the returned array, we have a paths array indicating what paths have just been updated. This isn't necessary, but does provide a slight [performance improvement](#updatedpaths--more-efficient-updating).\n\n##### **Asynchronous Behavior & Callback Argument**\n\nAfter `setState` has been called, you may want to access the newly updated state. You have two options for this, and they are *not* mutually exclusive. \n\n`setState` returns a `promise` that will resolve the updated state. Therefore, `setState` can be awaited in an async block. Alternatively (or in addition to), you can pass an optional callback as a second argument to `setState`. This callback will receive the updated state as its only argument. \n\n```javascript\nconst stateSchema = {myVal: 0}\n\nconst manager = new Spiccato(stateSchema, {id: \"asyncAndCallback\"})\nmanager.init()\n\n// Async/Await functionality\nconst someAsyncFunc = async () => {\n    const updatedState = await manager.setState({myVal: 1})\n    console.log(updatedState.myVal) // => 1\n}\n\n// Callback functionality\nmanager.setState({myVal: 2}, (updatedState) => {\n    console.log(updatedState.myVal) // => 2\n})\n```\n##### **updatedPaths & More Efficient Updating**\n\nThe third argument you can pass to `setState` is `updatedPaths`, an array defining which paths the state update will effect. This can take the form of either a an array of string arrays (`string[][]`), or an array of `spiccato` path objects which are accessed on the instance's `paths` property.\n\nThere are some benefits to explicitly defining the paths that are about to be updated. When an update occurs, `spiccato` compares your previous state to the newly updated state to determine which paths have updated so it can notify the appropriate listeners. This operation is recursive and becomes more expensive for objects with deeply nested structures. However, if you tell `setState` what you are about to update, it will skip this recursive check and just call event listeners based on the paths you define.\n\nWhen you use a functional argument in `setState`, you can return an array where the second element is this `updatedPaths` argument. If you take this route, the returned value from the function will supersede the direct input of `updatedPaths` to `setState`. This is particularly helpful if there is logic in your `setState` function that may or may not update certain values. By returning the `updatedPaths` value from the function call itself, you can always make sure that the `updatedPaths` array is an accurate representation of what has been updated. \n\n> Note: dynamic setters and nested setters make a call to `setState` under the hood. They make use of this efficiency boost by explicitly defining the updated paths. If the situation permits, dynamic setters and nested setters offer the easiest and most efficient solution for state updates. \n\n```javascript\nconst stateSchema = { \n    myVal: 0, \n    user: {\n        name: \"\", \n        phone: {\n            cell: \"\", \n            work: \"\"\n        }\n    } \n}\n\nconst manager = new Spiccato(stateSchema, {id: \"explicateUpdatedPaths\"})\nmanager.init()\n\n// Example with array paths. For this update we don't need to check the user object for changes because we are explicitly telling it that we're only updating `myVal`\nmanager.setState({myVal: 1}, null, [[\"myVal\"]])\n\n// Example with an array of path objects from the instance's 'paths' property. Here we use a functional input to update nested paths. By explicitly defining the changed paths, we don't need to check the whole state structure for updates.  \nmanager.setState(\n    prevState => ({\n        user: {\n            name: \"Jane\", \n            phone: {\n                ...prevState.user.phone, \n                cell: \"555-5555\"\n            }\n        }\n    }),\n    null,\n    [manager.paths.user.name, manager.paths.user.phone.cell]\n)\n\n```\nHowever, you should be aware of some potential drawbacks in explicitly defining your state updates.\n\n- If your defined paths do not exactly match your actual state update, you will either miss or erroneously trigger an event listener.\n- If your state update doesn't actually change your state (i.e. just sets the same primitive value again), en event listener will still trigger based on your explicit updated paths definition. \n\n```javascript\n/* AVOID THESE SCENARIOS */\n\nconst stateSchema = { val1: 0, val2: 0 }\n\nconst manager = new Spiccato(stateSchema, {id: \"BADexplicitUpdatedPaths\"})\nmanager.init()\n\n// This will trigger an event listener even though `val1` is still `0` after the update. A recursive check would not have flagged this change as an update.\nmanager.setState({ val1: 0 }, null, [manager.paths.val1]) \n\n// The update and the explicit paths do not match, and event listeners for `val2` will not be fired\nmanager.setState({ val1: 1, val2: 2 }, null, [manager.paths.val1])\n\n```\n---\n### Initialization Options\n| Property | Type  | Default | Description  |  \n|---|---|---|---|\n| id  | string (required) | null | A unique ID that can be used to retrieve the registered instance at a later time |\n| dynamicGetters | boolean   | true | Whether or not to dynamically generate getter methods based on the initialized state schema |\n| dynamicSetters | boolean | true | Whether or not to dynamically generate setter methods based on the initialized state schema |\n| allowDynamicAccessorOverride | boolean | true | If true, the user can replace a dynamic getter/setter with a function of the same name in either `addCustomGetters` or `addCustomSetters` | \n| nestedGetters | boolean | true | Whether or not to dynamically generate nested getter methods based on the initialized state schema |\n| nestedSetters | boolean | true | Whether or not to dynamically generate nested setter methods based on the initialized state schema |\n| debug | boolean | false | Whether or not to log out debug messages when utilizing the initialized manager |\n| enableWriteProtection | boolean | true |**WARNING**: *Disabling this removes safeguards that disallow direct state mutation. Disable only when absolutely necessary.* When active, only allows users access to an immutable state object. There is a performance cost that comes from a recursive copying operation to create this immutable object. If performance is a concern, you may consider disabling this safeguard.  |\n\n---\n### Project Wide State Management\n\nAfter a `Spiccato` manager has been initialized, you may want to access that same manager in several parts of your project. This can be achieved with standard JavaScript import/exports, or through the `Spiccato` class. \n\n**JS Import/Export**\n```javascript\nconst manager = new Spiccato({/* stateSchema here */}, {id: \"managerAccess\"})\nmanager.init()\n\nexport default manager;\n\n\n/*********** SOME OTHER FILE ***********/\nimport manager from 'path/to/manager/init/file';\n```\n\n**Reference Lookup**\n```javascript\nconst manager = new Spiccato({/* stateSchema here */}, {id: \"managerAccess\"})\nmanager.init()\n\n/*********** SOME OTHER FILE ***********/\nimport Spiccato from 'spiccato'\n\nconst manager = Spiccato.getManagerByID(\"managerAccess\")\n```\n\n---\n### State Schema\n\n**State Schemas** define the default key value pairs of the internal state for a `Spiccato` instance. Schemas are used during initialization of the instance to create dynamic setters and getters (if prescribed by the user in the initialization options), as well as throughout the life of the instance whenever state is accessed. \n\nIt is important that schemas are *complete* at time of initialization. This means that all the key value pairs that will need to exist at some point in the execution of the code *do* exist in the schema definition. Any key value pairs added after initialization will not be processed by the `Spiccato` instance and will have limited functionality in terms of dynamic setters, getters, and events.  \n\nSchemas are not inherently typed. When you define your schema and you have \"null\" values that are expected to be filled at a later time, it is best practice to assign those values to the falsey/empty type that they represent. However, there is nothing stopping you from assigning a value to `null` if that is required in your code. \n\nFor Example:\n\n```javascript\nconst stateSchema = {\n    isAdmin: false, // boolean false\n    count: 0, // zero for number type\n    message: \"\", // empty string\n    items: [], // empty array \n    credentials: {}, // empty object,\n    someOtherValue: null // this will work, but use sparingly\n}\n```\n\n| Type | \"Null\" Placeholder |\n|---|---|\n| Boolean | false |\n| Number | 0 |\n| String | \"\" |\n| Array | [] |\n| Object | {} |\n\n---\n### State Accessors\n#### Immutable Access\nEach `spiccato` instance has a `state` property. You can access values through this property, but by default, you cannot modify any value directly from this property. This safeguard is put in place when setting the initialization property, `enableWriteProtection`, to true. \n\nThere is a performance cost associated with write protecting your state in this way. If performance is a concern, you may consider disabling this feature. Note that if you disable write protection, any direct mutations will work, but event emitters associated with that state will not fire. This uncoupling of state updates can lead to unexpected and difficult to debug behavior. It is recommended to leave write protection enabled unless absolutely necessary.\n\nA compromise between safety and performance is to enable write protection in development mode to ensure all state updates are handled appropriately and predictably, and then disable it in production. The precise implementation of this logic will change depending on your environment, but it could look something like this:\n\n```javascript\nconst manager = Spiccato({myVal: 0}, {id: \"immutability\"})\nmanager.init({ enableWriteProtection: process.env.NODE_ENV === \"development\"})\n\nmanager.state.myVal // => 0\n\nmanager.state.myVal = 1 // This will throw an error in development mode\n```\n#### Dynamic Accessors\nAn alternative way to access and set state values is through dynamically generated accessors. \n\nThe default initialization behavior of a `spiccato` instance automatically creates accessor methods (getters and setters) for the each parameter in the associated state. In the case of nested values, nested accessors are also created. This behavior can be modified at the time of initialization. See [Initialization Options](#initialization-options) for more information on how to modify this behavior.\nFor example, take the following state schema and initialization:\n```javascript\nconst stateSchema = {\n    num: 0,\n    user: {\n        name: \"\",\n        age: 0 \n    }\n}\n\nconst manager = new Spiccato(stateSchema, {\n    id: \"dynamicAccessors\",\n    dynamicGetters: true,\n    dynamicSetters: true,\n    nestedGetters: true,\n    nestedSetters: true,\n})\nmanager.init()\n```\n\nFor this schema, dynamically generated accessor methods are stored in `setters` and `getters` in the following way.\n\n```javascript\n// getters\nmanager.getters.getNum() // => state.num\nmanager.setters.getUser() // => state.user\nmanager.getters.getUser_name() // => state.user.name\nmanager.getters.getUser_age() // => state.user.age\n\n// setters\nmanager.setters.setNum(1)\nmanager.setters.setUser({name: \"name\", age: 10})\nmanager.setters.setUser_name(\"some string\")\nmanager.setters.setUser_age(1)\n```\n\n#### When to Use Dynamic Accessors\nDynamic getters are particularly useful in closures. In a closure, when you access a state property directly, that value gets burned into the closure. A dynamic getter will always fetch a fresh version of the state property so your closure can know if it has updated.\n\n```javascript\n// This will cause an issue because `manager.state.myBool` is now burned into this closure and will not update. \nsetInterval(() => {\n    if(manager.state.myBool) {\n        /* DO SOMETHING HERE */\n    }\n}, 1000)\n\n// This is the correct way to handle this situation\nsetInterval(() => {\n    if(manager.getters.getMyBool()) {\n        /* DO SOMETHING HERE */\n    }\n}, 1000)\n```\n\nDynamic setters offer a shortcut to the more low level `setState` functionality. They have all the same behavior as `setState` (in fact, they call `setState` under the hood) including asynchronous functionality, callbacks, and explicit update paths. If you are ever performing a simple state update operation on a single parameter, dynamic setters are the easiest solution.\n\n```javascript\n// with `setState` you are responsible for ensuring only the state you want updated gets updated.\nmanager.setState({...manager.state.complexObject, value: 1}, (updatedState) => {\n    /* do something with callback here */\n})\n\n// with dynamic setters, all complexity is abstracted away for you. \nmanager.setters.setComplexObject_value(\n    1, \n    (updatedState) => {\n    /* do something with callback here */\n    }, \n    {explicitUpdatePath: true}\n);\n```\n\n---\n### Customization\n\nYou will likely find it necessary to extend the functionality of your state management beyond the dynamic getter and setter patterns described above. This is easily achieved with a number of customization options that are available on your `spiccato` instance.  \n\n> NOTE: It is important that you call the `.init()` method prior to adding custom getters and setters. Failure to do so will result in an error being thrown because the  `addCustomGetters` and `addCustomSetters` will exhibit strange behavior if your try to overwrite a dynamic getter/setter.  \n\nThe following four methods follow a similar pattern. They each take in an object where the keys are the custom function names, and the values are the functions themselves (`addNamespacedMethods` is slightly different, see below). The custom functions get bound to your `spiccato` instance, and can access the `this` parameter within their body. Because of this binding procedure, it is important that you do not pass in *arrow functions* to these methods, as they cannot be bound like typical JavaScript functions. \n\nAs an example:\n\n```javascript\n{\n    someFunction(){\n        /* This is the recommended format */\n    },\n\n    someOtherFunction: function (){\n        /* This will also work */\n    },\n\n    badIdea: () => {\n        /* This will not work */\n    }\n}\n```\n\n> **NOTE**: You can replace/overwrite dynamic getter and setter functionality by adding a custom getter/setter of the same name. \n#### addCustomGetters\nThe `addCustomGetters` method allows you to append customized getter function to the `getters` parameter of your state manager. \n\nIn the example below, you would get dynamic getters for a `user` `firstName` and `lastName`. The custom getter function that is added, `getUserFullName`, allows you to derive a new value based on existing state. Getting derived values from you state is the primary purpose of these custom getter methods.\n\n```javascript\nconst stateSchema = {user: {firstName: \"Foo\", lastName: \"Bar\"}}\n\n/* initialize manager code here ... */\n\nmanager.addCustomGetters({\n    getUser_firstName(){\n        // This function now replaces the dynamic nested getter fro the `firstName` property\n    }, \n\n    getUserFullName(){\n        return this.state.user.firstName + \" \" + this.state.user.lastName;\n    }\n})\n\nmanager.getters.getUserFullName() // \"Foo Bar\"\n```\n\n#### addCustomSetters\nThe `addCustomSetters` method allows you to append customized setter functions to the `setters` parameter of you state manager. Custom setters should call the `this.setState` method in their body.\n\nIn the example below, we have an initialized state with a `cart` array. If you used the dynamic setter called `setCart`, you would have to first get the array, add an item to it, and then pass the new array to the setter. The custom setter, `addOrderToCart` encapsulates this logic and makes it easier to reuse in the future. \n\nCustom setters are often helpful when dealing with arrays and objects and you want to set a particular index or property without modifying the entire structure. They are also useful when some logic is needed prior to setting a state value.\n\n```javascript\nconst stateSchema = {cart: []};\n\n/* initialize manager code here ... */\n\nmanager.addCustomSetters({\n    addOrderToCart(order){\n        this.setState(prevState => {\n            const updatedCart = [...prevState.cart, order];\n            return {cart: updatedCart}\n        })\n    }\n})\n\nconst order = {/* some order definition here */}\nmanager.setters.addOrderToCart(order)\n\n```\n\n#### addCustomMethods\n\nThe `addCustomMethods` method allows you to add functionality and flexibility to your state manager. Where `getters` and `setters` have specific and well defined purposes for accessing and modifying state, methods are less strictly defined. In essence, whenever you want to have simple and direct access to your state and all its built in functionality (setters/getters) within a function call, methods may provide a good option. \n\nSome common uses for custom methods are: \n- Making a network request and then using the response as an input for a setter.\n- Accessing state values and then using them to perform an external action such as updating the DOM or some other external variable. \n\n```javascript\nconst stateSchema = {isAdmin: false};\n\n/* initialize manager code here ... */\n\nmanager.addCustomMethods({\n\n    / *\n      * This method shows/hides content in the page based on certain state configurations.\n      * All the logic is self contained, and so this method can be called from anywhere in your application and you can expect it to perform correctly\n    * /\n    showOrHideAdminOptions(){\n        const adminOptions = document.querySelector(\"#admin-options-container\")\n        adminOptions.style.visibility = this.state.isAdmin ? \"visible\" : \"hidden\" \n    },\n\n    / * \n      * This method makes a network call and sets the state according to the response. \n      * Notice how it also calls the previous custom method we defined.\n    * /\n    getUserFromID(userID){\n        fetch(`https://some_endpoint/user/${userID}`)\n            .then(response => response.json())\n            .then(data => {\n                this.setters.setIsAdmin(data.role === \"admin\")\n                this.methods.showOrHideAdminOptions()\n            })\n    },\n})\n\nmanager.methods.getUserFromID(1);\n```\n\n#### addNamespacedMethods\n\nNamespaced methods are essentially custom methods, but that can be logically organized based on their purpose. The argument to `addNamespacedMethods` is also an object, but the first level of keys are the namespaces pointing to nested objects, and the nested objects are the function names and function implementations. \n\n```javascript\nconst stateSchema = {orderHistory: []};\n\n/* initialize manager code here ... */\n\nmanager.addNamespacedMethods({\n    // 'API' becomes a new namespace we can access directly on the manager \n    API: {\n        getOrderHistory(userID){\n            fetch(`https://orderHistoryEndpoint/${userID}/orders`)\n                .then(response => response.json())\n                .then(data => {\n                    this.setters.setOrderHistory(data.orders)\n                })\n        }\n    }\n})\n\nmanager._API.getOrderHistory(1);\n```\n\nNote that in `v^1.0.0`, namespaces are by default prepended with a underscore (`_`). The reason for this is addressed in the [Advanced Instantiation Patterns in Typescript](#advanced-instantiation-patterns-in-typescript) section. In a typescript setting, you should follow the pattern outlined there for type safety. In a normal JavaScript setting, you can include a second argument to the `addNamespacedMethods` call. This is a boolean, and indicates if these typescript support guidelines should be followed. Set this to `false` and there will be no `_` prepended to your namespaced methods.\n\n```javascript\nmanager.addNamespacedMethods({\n    API: {/* implementation here */}\n}, false)\n\nmanager.API // you can now access your namespace without the `_` prefix \n```\n#### Customization Chaining\n\nYou can chain the `addCustomGetters`, `addCustomSetters`, `addCustomMethods`, and `addNamespacedMethods` calls after the `init` call.\n\n```javascript\n\nconst manager = new Spiccato({/* your state here */}, { id: \"chaining\" });\n\nmanager.init()\n    .addCustomGetters({ /* custom getters */ })\n    .addCustomSetters({ /* custom setters */ })\n    .addCustomMethods({ /* custom methods */ })\n    .addNamespacedMethods({ /* custom namespaces */ });\n\n```\n\n---\n\n### Performance Implications & setStateUnsafe\n\nIn typical usage you will use dynamic or custom setters to mutate state. This is a safe operation as the underlying logic prevents state mutations from occurring without firing the associated state update events. However, in situations where state updates are coming at a high rate, this may not be the most performant solution. The reason is that each update potentially causes a traversal of state to determine what has changed, and complex state properties (like objects and arrays) will copy their contents to a new object and let garbage collection clean up the old instance. \n\nFor this reason, `setStateUnsafe` is provided as a hyper performant option. There are a few things to consider when using this method. First, as the name suggest, this is an unsafe state update as it allows you to mutate state directly. The expectation is that the user supplies an array indicating what has changed so the proper state update events can be fired. However, this is not enforced, hence the unsafe nature of the method.\n\nSecond, in order to mutate state directly, you must initialize your spiccato instance with `enableWriteProtection` set to `false`. If this is not done and you attempt to call `setStateUnsafe`, it will throw an `ImmutableStateError`. \n\nThe `setStateUnsafe` method has one required argument, and one optional argument. The required argument is a function that receives the current state for direct mutation. This function must return an array indicating what has been updated (see [AddEventListener](#addeventlistener) for acceptable array formats that will trigger events). The second optional argument is a callback that will receive the updated state as its only argument. An alternative to callback is to await the call to `setStateUnsafe`. It returns a promise which will resolve to the updated state. \n\n```javascript\nconst performanceManager = new Spiccato({complexVal: {val1: 1, val2: \"hello\"}}, {id: \"performance\", enableWriteProtection: false});\nperformanceManager.init();\n\nasync function unsafeButFast() {\n    const updated = await performanceManager.setStateUnsafe((state) => {\n        state.complexVal = {val1: 0, val2: \"goodbye\"};\n        return [performanceManager.paths.complexVal]\n    })\n}\n```\n\nYou should use `setStateUnsafe` with caution and only when performance is a high priority. Otherwise, you should opt for dynamic or custom setters whenever possible.  \n\n---\n\n### Events\n\nWhen a `Spiccato` instance is initialized, it dynamically creates events for all the properties defined in the state schema. \n\n#### AddEventListener\n\nYou can add event listeners to a `Spiccato` instance. In keeping with common JS event subscriptions patterns, you simply call the `addEventListener` method on your instance, passing in either an event name *or* an array of paths within your state. You can add multiple event listeners to the same event. \n\n**Name Input**: Event names conform to the following format: \"on_\" + PATH_TO_STATE_PROPERTY + \"_update\". If you have a state property named \"myVal\", the associated event that would trigger when that property changes would be \"on_myVal_update\". In the case of nested properties, it follows the same format with each level of nesting being separated by an underscore \"\\_\". E.G. \"on_level1_level2_value_update\".\n\n**Path Input**: Rather than formatting a string like the examples above, you may like to put in the path to your state resource when adding your event listener. This can be accomplished in two ways. First, you can put in a `string[]` denoting the path to your resource. For example: [\"myVal\"], or [\"level1\", \"level2\", \"value\"]. Alternatively, your `spiccato` instance will have a `paths` property. This property provides an idiomatic way to input paths to event listeners that prevents common formatting or spelling errors when writing out long string sequences. You can do something like: `manager.paths.myVal`, or `manager.paths.level1.level2.value`. Should you attempt to access a path that is not defined in your `stateSchema`, a `StatePathNotExistError` will be thrown. \n\n```javascript\nconst manager = new Spiccato({\n        num: 1,\n        user: {\n            phone: {\n                cell: \"555-5555\",\n                work: \"123-4567\"\n            }\n        }\n    }, \n    {id: \"main\"}\n)\nmanager.init();\n\n// Path object input (recommended)\nmanager.addEventListener(manager.paths.user.phone.work, function(payload){\n    /* do something here */\n})\n\n// Formatted event name input\nmanager.addEventListener(\"on_num_update\", function(payload) {\n    /* do something here */\n})\n\n// String array input\nmanager.addEventListener([\"user\", \"phone\", \"cell\"], function(payload){\n    /* do something here */\n})\n\n\n```\n#### Event Payload\nThe event `payload` is an object with two properties, `path` and `value`. The `path` property is the full path to the state resource from the top level of your state object. The `value` property is the value after the update. \n\nYou can also subscribe for *any* updates to your state object with the `\"update\"` event type.\n\n```javascript\nmanager.addEventListener(\"update\", function(payload){\n    /* do something here */\n})\n```\n\nFor the general `update` event, the payload differs slightly. Since there is no single path being subscribed to, the payload for this event type only has a `state` property with the current values for the entire state object. \n\n#### RemoveEventListener\n\nYou can remove an event listener with a familiar pattern as well. Similarly, `removeEventListener` can take in a `string`, `string[]`, or `paths object` as its first argument defining the path. \n\n```javascript\n// define your callback\nconst callback = (payload) => {\n    /* do something here */\n}\nconst otherCallback = (payload) => {\n    /* do something here */\n}\n\n// add your callback to a particular vent\nmanager.addEventListener(\"update\", callback)\nmanager.addEventListener(manager.paths.myVal, otherCallback)\n\n// remove callback/event listener when it is no longer needed\nmanager.removeEventListener(\"update\", callback)\nmanager.removeEventListener(manager.paths.myVal, otherCallback)\n```\n\n> **Note**: It is important you pass in the same function reference when you remove a listener as you did when you originally subscribed. \n\n---\n### Errors\n\n`Spiccato` exposes custom errors that you can import into your project.\n\n```javascript\nimport {/* SOME_ERROR_TYPE */} from 'spiccato/errors';\n```\n\n| Error | Reason | Remediation |\n| --- | --- | --- |\n| ProtectedNamespaceError | The user has added a namespaced method that overwrites an existing `spiccato` property (e.g. state, getters, setters, etc.) | Select a different namespace for your namespaced method |\n| ImmutableStateError | The user has attempted to modify state directly without a setter. This error is not thrown when `enableWriteProtection` is false. | Use `setState`, or a setter (dynamic or custom) to modify state. Alternatively, set `enableWriteProtection` in initialization options to false. |\n| InvalidStateUpdateError | The user has provided an invalid value for the first argument to `setState` | Ensure that all calls to `setState` receive either an object or a function that returns an object as the first argument. |\n| StatePathNotExistError | The user has attempted to access a property within the instance `paths` object that does not exist | Ensure that the `stateSchema` does define the indicated path and that all path properties are spelled correctly | \n| ReservedStateKeyError | The user has supplied a key in state that is reserved by `spiccato` to perform additional functionality. | Select a different key name for the indicated state resource |\n| ManagerNotFoundError | The class method, `getManagerByID`, returns `undefined`. This error must be thrown manually. | Check that the ID supplied is associated with an existing manager ID. |\n\n---\n\n### Static Methods\n\nThe Spiccato class itself has static methods and accessors that can be used to help track all the spawned manager instances and their states.\n\n| Manager/Accessor | Description |\n| --- | --- |\n| getManagerById | given a string id, returns a manager instance with that unique id if it exists | \n| clear | Clears its recording of all spawned managers | \n| state | this is a `get` accessor that returns an object with the current state from all spawned managers. The keys at the top level of this object are the IDs of the spawned managers | \n\n\n---\n## Typescript Support\n*Version 1.0.0 and higher includes improved typescript support for full type safety and intellisense*  \n\n### Introduction\n`Spiccato` auto-generates much of its core functionality at runtime. As such, achieving full type safety through typescript can be challenging because the precise interface of the state manager is not known at compile time. Several utility types have been included to help ease the burden of achieving type safety with `Spiccato` state managers. Even with these utility types, the user must supply some information about the interface that will be generated.\n\n---\n\n### Basic Instantiation Patterns in Typescript\n\nA basic typescript instantiation could be as simple as this:\n\n```typescript\nconst stateSchema = {myVal: 0, myString: \"hello\"};\n\nconst manager = new Spiccato<typeof stateSchema>(stateSchema, {id: \"tsDemo\"});\nmanager.init()\n```\nwhile this will work if you only want to consume state, it will fail to provide type safety for any dynamic or custom getters, setters, or methods. To achieve this, you can opt for a slightly more verbose pattern like the following:\n\n```typescript\n// IMPORTS\nimport {GetterMethods, SetterMethods, StateObject, SpiccatoInstance} from 'spiccato/types';\nimport Spiccato from 'spiccato';\n\n// STATE\nconst stateSchema = {myVal: 0, myString: \"hello\"};\n\n// GETTERS\ntype CustomGetters = {\n    myCustomGetter: () => string;\n}\ntype Getters = GetterMethods<typeof stateSchema, CustomGetters>;\n\n// SETTERS\ntype CustomSetters = {\n    myCustomSetter: (n: number) => Promise<StateObject>;\n}\ntype Setters = SetterMethods<typeof stateSchema, CustomSetters>;\n\n// METHODS\ntype Methods = {\n    myCustomMethod: (n: number) => void;\n}\n\n// SIGNATURE\ntype InstanceSignature = SpiccatoInstance<typeof stateSchema, Getters, Setters, Methods>;\n\n// INSTANTIATION\nconst tsManager = new Spiccato<typeof stateSchema, Getters, Setters, Methods>(stateSchema, {id: \"tsDemo\"})\ntsManager.init();\n\n// Apply custom functionality below\ntsManager.addCustomGetters({\n    myCustomGetter(this: InstanceSignature) {return this.state.myString.repeat(this.myVal)},\n})\n\ntsManager.addCustomSetters({\n    myCustomSetter(this: InstanceSignature, n: number) {\n        return this.setState((prevState: typeof stateSchema) => {\n            return { myString: prevState.myString.repeat(n) };\n        })\n    }\n})\n\ntsManager.addCustomMethods({\n    myCustomMethod(this: instanceSignature, n: number) {\n        console.log(n * this.state.myVal);\n    }\n})\n\n```\n\nThere are a few points to highlight here. First are the utility types that you import from `spiccato/types`. Second, note the pattern for defining getters and setters. First, you define the shape of your custom getters/setters. This includes the function definition (arguments and return type) for each getter/setting that you will apply. Then you pass in generics for the state type and these customization definitions to the `GetterMethods` and `SetterMethods` types respectively. By passing in the state, this types will auto generate the dynamic getter and setter type definitions for you, and then you extend those definitions with your customizations. If you don't want to auto generate setters and getters, you can simple pass `{}` in place of your state type. \n\n### Advanced Instantiation Patterns in Typescript\n\nIn the event that you want to add namespaced methods to your manager, you will need to extend the base `Spiccato` class to accommodate the added accessor properties. \n\n```typescript\nimport {GetterMethods, SetterMethods, StateObject, SpiccatoInstance, SpiccatoExtended} from 'spiccato/types';\nimport Spiccato from 'spiccato';\n\nconst stateSchema = {myVal: 0, myString: \"hello\"};\n\ntype Getters = GetterMethods<typeof stateSchema, {}>;\ntype Setters = SetterMethods<typeof stateSchema, {}>;\ntype Methods = {};\n\ntype CustomNamespace = {\n    someNamespacedMethod: () => void;\n}\n\ntype Extensions = {\n    customMethods: CustomNamespace;\n}\n\ntype BaseSignature = SpiccatoInstance<typeof state, Getters, Setters, Methods>;\ntype InstanceSignature = SpiccatoExtended<BaseSignature, Extensions>;\n\nclass SpiccatoExtended extends Spiccato<typeof stateSchema, Getters, Setters, Methods, Extensions> {\n    get customMethods(): CustomNamepsace { return this._customMethods as CustomNamespace };\n}\n\n\nconst extendedManager = new SpiccatoExtended(stateSchema, {id: \"extended\"});\nextendedManager.init();\n\nextendedManager.addNamespacedMethods({\n    customMethods: {\n        someNamespaceMethod(this: InstanceSignature) {\n            console.log(this.state.myVal);\n        }\n    }\n})\n\n```\n\nIn this example, the custom defined `SpiccatoExtended` class extends the base `Spiccato` class and adds a get accessor method called `customMethods`. This get accessor is typed to return an object that adheres to the shape of the `CustomNamepsace` type. in the accessor implementation, note that it actually returns `this._customMethods`. Internally, the manager instance has `this._customMethods` as a property, but it is untyped. By wrapping it in a get accessor, we can supply typing information to enforce type safety and provide intellisense completion. \n\nFinally, we call the `addNamespacedMethods` with an object that has `customMethods` as a property. This in turn points to another object with our actual method implementations. Note that we supply the `this` keyword definition in the signature, and assign it to the `InstanceSignature` type. This will give us full type safety and intellisense within the method.  \n\n> Note: If you use the included [command line interface](#command-line-interface) to generate your state resource file structure and you include the `--typescript`, flag, this advanced type initialization pattern will be followed. \n\n---\n\n### Typing your State Schema\n\nWhen typing your state schema, there are some special considerations. These considerations particularly apply to state properties that are initialized as `null` or `undefined`, or properties that can take the form of multiple types. Consider the following:\n\n```typescript\nconst myState = {myVal: null, myString: null};\n```\n\nif you use the `typeof` keyword to cast this to a qualified typescript `Type`, it won't be able to determine useful types for your state properties. If initializing a state property to `null` or `undefined` is necessary, you should consider one of the following approaches:\n\n```typescript\n// extension\nconst myState = {myVal: null, myString: null};\n\nType State = typeof myState & {\n    myVal: null | number,\n    myString: null | string\n}\n```\n\nOr:\n\n```typescript\n// manual typing\nType State = {\n    myVal: null | number,\n    myString: null | string\n}\n```\nIt is also important that you follow one of these approaches if a particular state property can be multiple types.\n\n```typescript\nType State = {\n    myVal: null | number | number[] // etc.\n}\n```\n\n\n---\n\n### Type Exports\n\n```typescript\nimport type {/* SOME TYPE HERE */} from 'spiccato/types';\n```\n\n| Type | Description |\n| --- | --- |\n| StateSchema | Type for the state schema passed into a `spiccato` initialization. |\n| StateObject | Type for the manifestation of state after `spiccato` instance is initialized |\n| SpiccatoInstance | Type that defines the baseline, unextended manager instance. Takes 4 generics <State = {}, Getters = {}, Setters ={}, Methods = {}>. These generics define the interfaces for state, getters, setters, and methods, respectively. |\n| SpiccatoExtended | Type that defines a manager instance that has namespace extensions. Takes 2 generics <BaseInstance, Extensions = {}>. The base instance is a `SpiccatoInstance`, and the extensions define the interface(s) to any added namespaces. |\n| GetterMethods | A utility type to merge auto generated getters with custom getter method definitions. Takes 3 generics <T, Custom, Depth=12>. `T` is the state type, `Custom` are the custom defined getter method definitions, and `Depth` defines how deep a nested getter traversal should burrow into the state definition (the max is 12 levels) |\n| SetterMethods | A utility type to merge auto generated setters with custom setter method definitions. Takes 3 generics <T, Custom, Depth=12>. `T` is the state type, `Custom` are the custom defined setter method definitions, and `Depth` defines how deep a nested setter traversal should burrow into the state definition (the max is 12 levels) |\n| managerID | Type for ID associated with a specific manager | \n| EventPayload | Type for payload that is passed as an argument to the callback of a fired event |\n| InitializationOptions | Interface for initialization options passed to a `spiccato` initialization. |\n| StorageOptions | Interface for storage options passed to `connectToLocalStorage` call. |\n\n\n---\n\n## Connect to Local Storage\n\nWhen deployed in a browser environment, you will have access to the `localStorage` API. `localStorage` allows you to save key value pairs to a specific domain and retrieve those values at a later time, even after page reloads. \n\n`Spiccato` allows you to easily mirror your state in `localStorage`. There are two main reasons you may want to do this: \n\n- Persist state on a certain domain that survives page reloads\n- Synchronize state updates between two or more windows on the same domain. \n\n### LocalStorage Concepts\n\nThe browser's `localStorage` API allows you to store key value pairs specific to a domain. However, the values in these pairs must always be strings. The browser will coerce non-string types into strings. In the case of primitives, they simply become their string representation (e.g. 5 becomes '5', true becomes 'true', etc. ). However, for non-primitives like objects and arrays, they become *\"[object Object]\"*. Therefore, when mirroring your state in `localStorage`, you must first `stringify` it, or all your data will be lost. \n\n`Spiccato` handles this process for you, but is still bound by the limits of JavaScript object stringification. For instance, you cannot have circular structures or functions in your state if it is being connected to `localStorage`. To learn more about stringification, see [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify). In situations where your state does have a value that cannot be stringified, you can omit that specific value though `privateState` (see [storageOptions](#storage-options)).\n\nYou should also be aware that placing state in `localStorage` makes it easily accessible to the end user. Any `localStorage` value can be accessed and modified without any special permissions, and so you should refrain from placing any values in there that you do not want the end user to have complete control over. \n\n---\n### Basic Usage\n\n```javascript\nconst stateSchema = {\n    user: {name: \"\", isAdmin: false},\n    cart: [],\n}\n\nconst manager = new Spiccato(stateSchema, {id: \"localStorageDemo\"});\n\nmanager.connectToLocalStorage({\n    persistKey: \"lsDemo\", // this is the key under which the state will be saved in localStorage\n    initializeFromLocalStorage: false, // store in localStorage only for this session\n    privateState: [[\"user\", \"isAdmin\"]] // keep some state private so the end user cannot access it. \n    providerID: \"stateProvider\"\n})\n\nmanager.init()\n\nlocalStorage.getItem(\"lsDemo\") // => '{user: {name: \"\"}, cart: []}'\nmanager.setters.setUser_name(\"Sally\");\nlocalStorage.getItem(\"lsDemo\") // => '{user: {name: \"Sally\"}, cart: []}'\n```\n\nNote in this example how the `init` method is called *after* `connectToLocalStorage`. This is necessary to setup all the required functionality that will handle `localStorage` persistence and updates.  \n\n### Storage Options\n\n| Property | Type | Default | Description |\n| --- | --- | --- | --- |\n| persistKey | string (required) | null | A unique key within the domain. This is the key under which the state will be stored in localStorage. |\n| initializeFromLocalStorage | bool | false | Whether or not to take the default state values from local storage at time of initialization |\n| providerID | string (required) | null | The id of the window that is designated as the state provider. |  \n| subscriberIDs | string[] | [] | An array of IDs indicating which spawned windows may subscribe to and receive state updates. |  \n| clearStorageOnUnload | bool | true | Whether of not to clear the state loaded to `localStorage` when the provider window is closed. |\n| removeChildrenOnUnload | bool | true | Whether of not to recursively close spawned children windows when the provider window (or relative parent window) is closed. |\n| privateState | string[] or string[][] or (instance path object)[] | [] | An array of strings, array of nested string arrays, or array of instance path objects (defined on `instance.paths`). Indicates state paths that will not be persisted to local storage. Provider windows will have access to all state regardless, but subscriber windows will only have access to state values not defined within this option. | \n| deepSanitizeState | bool | true | Whether or not any subscribers will have basic knowledge of private state? By default (true), subscribers will initialize without any knowledge that private state paths exist. This means that dynamic setters, getters, etc. will not be created for any paths defined within `privateState`. Set to false if you still want to your subscribers to know about private state but not the underlying data from the provider. \n\n---\n\n### State Persistence\n\nThe following configuration shows how to persist your state in a browser in such a way that it will survive a page reload. \n\n```javascript\nconst stateSchema = {\n    colorMode: \"light\",\n    accessKey: \"\"\n};\n\nconst manager = new Spiccato(stateSchema, {id: \"persistDemo\"});\n\nmanager.connectToLocalStorage({\n    persistKey: \"statePersistDemo\",\n    initializeFromLocalStorage: true,\n    providerID: \"persistProvider\",\n    clearStorageOnUnload: false,\n    privateState: [manager.paths.accessKey]\n})\n\nmanager.init();\n\nmanager.setters.setColorMode(\"dark\");\nmanager.setters.setAccessKey(\"12345\");\nmanager.state // => {colorMode: \"dark\", accessKey: \"12345\"}\n\n```\n\nThe main options to pay attention to here are the `initializeFromLocalStorage` and `clearStorageOnUnload`. \n\nWhen `initializeFromLocalStorage` is set to true, the `spiccato` instance will first look in local storage to get its default state values. Anything not found in `localStorage` but that exists in the `stateSchema` will be initialized in their usual way. In this instance, we don't want the end user having total control over the `accessKey` parameter, but we do want to persist their choice in `colorMode`. We have setup our `privateState` accordingly.\n\nSecond, we want to make sure we don't reset the `localStorage` state when we reload the page, so we set `clearStorageOnUnload` to false. This is the main parameter that allows us to persist state over page reloads. \n\nWhen the user reloads the page, this is what their state will look like:\n\n```javascript\nmanager.state // => {colorMode: \"dark\", accessKey: \"\"}\n```\n\n### Inter Window Communication\n\n`localStorage` can be used to share state between two or more windows on the same domain that are open at the same time. However, synchronizing state across windows can be a complex task that requires you to consider many contingencies. `Spiccato` abstracts this complexity behind the `connectToLocalStorage` functionality and a `windowManager` API. \n\n#### windowManager\n\nIf you're using `Spiccato` inside a browser environment, your state manager instance will be initialized with a `windowManager` property. At a basic level, the `windowManager` wraps `window.open` and `window.close` methods. However, it also adds functionality to track references to spawned windows, send initialization parameters to those windows, and synchronize the lifecycle of spawned windows relative to their immediate parent. \n\n**!!!IMPORTANT!!!** - If you're are using `spiccato` to manage state between multiple windows, you should use this `windowManager` API to open/close those windows. If you use the browser's standard methods for managing spawned windows, you will miss out on some additional functionality that `spiccato` provides. \n\nSpawning a new window and managing its state from the parent (or the other way around) is simple:\n\n```javascript\nconst stateSchema = {\n    backgroundColor: \"#FFF\",\n    superSecretKey: \"\"\n};\nconst manager = new Spiccato(stateSchema, {id: \"multiWindowDemo\"});\nmanager.connectToLocalStorage({\n    persistKey: \"config\",\n    initializeFromLocalStorage: false,\n    clearStorageOnUnload: true,\n    removeChildrenOnUnload: true\n    providerWindow: \"main\", // defines the originating state provider window\n    subscriberWindows: [\"config\"], // defines what windows may receive state updates\n    privateState: [manager.paths.superSecretKey],\n    deepSanitizeState: true\n});\n\nmanager.init();\nmanager.windowManager.open(\"/settings\", \"config\", {height: 500, width: 500});\n```\nIn this example we initialize a new `spiccato` state manager and connect it to local storage. When managing state between multiple windows, there are a few important options that must be passed to the `connectToLocalStorage` call. \n\nFirst, you must define a `providerWindow`. At time of initialization, if the window that is open doesn't have a `window.name` property set, it will be assigned this `providerName`. There can only be one provider window at a time. The provider window can access all state properties even if some of those properties have been marked as private. \n\nSecond, you must provide an inclusive array of all subscriber window names that you intend to recognize throughout the lifecycle of your application. If the example above, our call to `connectToLocalStorage` says that it will recognize one subscriber window named `config`.\n\nFinally, in our `manager.windowManager.open` call, we tie everything together. Here, we're saying *\"open a window at the route '/settings', name that window 'config', and pass it the following init params.\"* When that window opens and initializes its local `spiccato` instance, since its name links it to the approved list of subscribers, it will look at the current state given by the provider window and set that as the default value. Note that it will not receive the *superSecretKey* state parameter because that is marked as private and only the provider will have access to it. Because `deepSanitizeState` is set to true, the subscriber window will not even know that `superSecretKey` is a property that the provider window has access to, and will ignore it when setting up its own dynamic setters and getters. \n\nTo programmatically close a spawned window, you only need to call the `windowManager.close` method. \n\n```javascript\nmanager.windowManager.close(\"config\");\n```\n\nSince the `windowManager` tracks references to all spawned windows, you only need to provide the name of the window to the `close` method and it will remotely close that instance. You can also close all spawned instances like this:\n\n```javascript\nmanager.windowManager.removeSubscribers();\n```\n\nIn your `connectToLocalStorage` call, if you set `removeChildrenOnUnload` to `true`, then when the immediate parent of a spawned window is closed all it's immediate children will be closed as well. Note the spawned windows may spawn addition children windows. If the original provider window closes, all spawned windows will close recursively. If spawned window closes that had additional children windows, that window and its children will close recursively, but any parents/grandparents will remain.  \n\n---\n\n## Command Line Interface\n\nA CLI is included with the `Spiccato` install, and it allows you to quickly create a `spiccato` state manager instance and associated support files (getters, setters, methods, etc.). \n\n> **Note**: The CLI is only implemented for UNIX systems at this time. \n\n### Package.json Script\n\nThe easiest way to execute the CLI script is to add a shortcut to your `package.json` file. \n\n```json\n\"scripts\": {\n    \"spiccato-cli\": \"node ./node_modules/spiccato/cli.js\"\n}\n```\n\n### Keyword Arguments & File Structure\n\nThe CLI allows you to specify a root directory in which to save all your state management resources. This is done with the `--root=` argument. You can also specify a name for your manager with the `--name=` argument. If you don't provide a `root` or `name` argument in your call to the CLI, a setup wizard will prompt you to enter values for each. \n\nAs an example:\n```\nnode ./node_modules/spiccato/cli.js --root=./path/to/root --name=main\n```\n```\n<ROOT>\n|___<NAME>\n    |___<NAME>Manager.js (Spiccato initialization & configuration)\n    |___stateSchema.js (required: default state for Spiccato instance)\n    |___getters.js (optional: custom getter definitions)\n    |___setters.js (optional: custom setter definitions)\n    |___methods.js (optional: custom method definitions)\n```\nThe `--typescript` flag is supported in version ^1.0.0. If this is included, all generated files will be `.ts` files, and an additional `types.ts` will be generated in the `<NAME>` directory. See the [Advanced Instantiation Patterns in Typescript](#advanced-instantiation-patterns-in-typescript) for details on how these `.ts` files are formatted. \n\nHere is an example with the `--typescript` flag:\n\n```\nnode ./node_modules/spiccato/cli.js --root=./path/to/root --name=main --typescript\n```\n```\n<ROOT>\n|___<NAME>\n    |___<NAME>Manager.ts (Spiccato initialization & configuration)\n    |___stateSchema.ts (required: default state for Spiccato instance)\n    |___getters.ts (optional: custom getter definitions)\n    |___setters.ts (optional: custom setter definitions)\n    |___methods.ts (optional: custom method definitions)\n    |___types.ts (included every time --typescript is used)\n```\n\n### CLI Flags & Options\n\n> **Note**: the examples below assume you have setup a `package.json` script like the one shown above. Replace `spiccato-cli` with your script name, or simply run directly through node. If you are running through a `package.json` script, make sure to include the `--` before any arguments/flags so they get passed to the script.\n\nIf you run the CLI without any options or flags set, you will be taken to a setup wizard which will walk you through setting up your Spiccato instance. Simply follow the instructions printed to your terminal. \n\n### Keyword Options\n| Keyword Flag | Value | Description |\n| --- | --- | --- |\n| --root | file path string | Where to place the state resource files relative to the current directory |\n| --name | name of the state resource | the folder name and name of the state manager to be applied |\n| --typescript | none | Include this keyword flag to generate a `types.ts` file, and to build your manager file and resource files with typescript support |\n### Support File Flags\n\nIf you indicate any of the flags below, a support file for that item will be created, and it will automatically be added to your Spiccato instance. \n\n| Flag | Support File | Description |\n| --- | --- | --- |\n| -S | stateSchema.js | Default state | \n| -g | getters.js | Custom getters |  \n| -s | setters.js | Custom setters |  \n| -m | methods.js | Custom methods | \n\n**Example:**\n\nIn the example below, a file called `mainManager.js` will be created for you housing the `Spiccato` instance configuration, as well as three support files, `stateSchema.js`, `setters.js`, and `methods.js`. These will all be saved into a directory called `main`. Since this call did not specify a `root`, you will be prompted to supply one.\n\n```\nnpm run spiccato-cli -- --name=main -Ssm\n```\n\n### Changing Default Names\n\nIf you want to change the name of a support file to be more syntactically correct based on your usage, you can do that by specifying `--<SUPPORT_FILE_NAME>=<DESIRED_NAME>`. If you specify a support file in this way, you do not need to include its flag also.  \n\nPossible support file names are `state`, `getters`, `setters`, and `methods`. \n\n**Example:**\n\n```\nnpm run spiccato-cli -- --name=main -Sgs --methods=API \n```\n\nNow, rather than a file named `methods.js`, you will have a file called `API.js`. Note that this only changes the file name, and not the name within your Spiccato instance. \n\nAs the example above shows, you can combine flags and rename files in the same command. The above will create the following state management resource for you:\n\n```\n<ROOT>\n|___main\n    |___mainManager.js\n    |___stateSchema.js\n    |___getters.js\n    |___setters.js\n    |___API.js\n```\n","readmeFilename":"README.md"}