{"_id":"classy-solid","_rev":"27-09521a4d02db8b1d603e9f994233c8a5","name":"classy-solid","dist-tags":{"latest":"0.5.2"},"versions":{"0.1.0":{"name":"classy-solid","version":"0.1.0","keywords":["components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.1.0","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"0bc475ce3e7d33e3804d1a5d63b8d591c3d91a23","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.1.0.tgz","fileCount":50,"integrity":"sha512-L4B0gKsxpBCYocK4dzsQejpN0cjMVZM2bcIj5/uxKoBQOI/imYLsM/29v93t0udPj3SvKHH+/aluZzJh9mvnNg==","signatures":[{"sig":"MEYCIQCYX8zE9IRMtu0mllOWpuyUXnLXEMhNUZpbtzz2CsjkiwIhAMJzRfvdoNxuKrSx9//pt80hzZSQJ04qjLch0JJVzoR6","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":245653,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiSRHiACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmrRtQ//bgRCQdQH4qP9qs05Pit/KjNXr5bGfDkJugMBNxfzg7vsYYQv\r\ns8iDyY+8Cra7WMj1FdaIQKNxIk8PFW+WKb54h/IX/3AoPlkJkG7kVK9vkfyM\r\nmFYi/Kvf9+f8Pp2uRSHvENgbR4O9GGM4T99V1O0wYsEloXVmamlzE1GAHeNT\r\na7ej8YzBC641JTXpETFFQVSqGfYadUDYZiiQ8AitVwAynQrIsqRnPZox5JTb\r\nrt9VPqRxtl6prkgLg7vu2b7wzv3rDFmlT814YWHyxF7rdZ3S0ZRzxm+g1eQu\r\n7yYWrIJSDa1+/TwVXsb1CfCrzNkLltDqqc4k9DP7TIluvj40w0s32S4FS91s\r\nesp7DKtY8CikHhQuhsCOyRh677UVZBaW7yWqX0+6oIwj5erosnkyf0mTx1Yu\r\npBxNzIDSxhbhY+j4cP9C6UlNXjyMdqJjU4SB1+RnVsO6q8Uy+4GBs6qEaapr\r\nQ6apdULvmFUdsSum6kSPocSWPfOSAvs69SawzAsoAsiwyp8GEZRqFzx+UeEy\r\nSD/MzaKRMkQPPaOCmTkkr0LQmO80Cn9twrvdJ5lG7tOQGwwViqPFxigeVMhp\r\n7ZEs1ZHPMOxe/mJfYfsPIOo6g8yQKaCwv6ce/I7E+YXdc/8fAvr7bxEzqy1p\r\nOJmMfCjSoZur/MIkQMnAqtu5ChD6vt84BA0=\r\n=9QlE\r\n-----END PGP SIGNATURE-----\r\n"},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"8fa7e7e50bb7e88822230dcd7576baeb41f46454","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.3.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.3.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.7.0","typescript":"4.4.3"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.1.0_1648955873863_0.6340570324175052","host":"s3://npm-registry-packages"}},"0.1.1":{"name":"classy-solid","version":"0.1.1","keywords":["components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.1.1","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"b3cb8c7dc5070fd05a3ea26c0f6fed2647e3e995","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.1.1.tgz","fileCount":55,"integrity":"sha512-v+xW5tyilK3/eKnriXGTLNDTxmgSx+ku95QbSH5KNUwT5m3Wmf+25WjEpfzq/1Voc0Tso5K1PCP95zEItcoUCQ==","signatures":[{"sig":"MEUCIQDzx98Eedj+0HleRBmV5UeQhgb7WAfPdkXh+ybI2xp9QgIgNJ6qF4L+a6jaUSNmTU5PRXqtLn6/wQcb7dETUU2ZwbU=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":257113,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiT9bIACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmrGfQ/8CR4r+Krie/qFV3U0H0rFMKh2Y6CMJkk8HVbou5F3C2YlB659\r\nQYQd17d8lmq+ryZXkaJgmw1OdYkx8BCNJouRK7p0OOrHH3DxqLKF4r5VLuGU\r\nBEWGrRFH8+8cFjD/XPnwVdJrbMf5zECBTcU7moI8skSWt49g468a+SDbF6Vm\r\nnhluhhfaLFAFUoKThUqiqRWHCS+KhAbymhDgsXKfrED5wtWkCrnc6aw4B9jf\r\noe8sU3CW/GG0hH6EHOIP9rntbOfKaE7ythLmBCDgCKII4KGoCHjdq1otRSCv\r\nEBRvYrhZzLKKQ/bZHjs9yB5l9151e8XQrDvYsMX22sbSsXE00ra12G4jUkM3\r\nDkstpfb5h8Ea4fqSP37l9bYBf/4eyE9K0E2TdTBlBBolflmkau/aclcdjQbW\r\nezouqQ8N6Mk2ZtDo2WFlsxIYvuPx4wiHZsp+y2g2Z5+SE+RTrdEmj/Lfb4Dj\r\nQ2LTlGBxwj6IS+ltJa1p1TF0FvMnvkU9vF5EYqM9kGXGCu0LGPKbEjeWGuo3\r\nocWv4oOQskOcd4UbC0zzbZLPtjOr9DWwrWA4ZhZqR3jm9KnV0XxH+gqOZZtu\r\nnWFBsmoItzKCBouvIFcZfbtRtnJvIFBt1JNxEyEbvWjeJU2uCakBcvNsQkXB\r\noCXkxIS/REjeF+wXicKIhBqa7OZc0teAhTQ=\r\n=cReA\r\n-----END PGP SIGNATURE-----\r\n"},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"719907b6491c3e41fd6358b2ff16e0959d118d7e","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.3.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.3.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.7.0","typescript":"4.4.3"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.1.1_1649399496031_0.7151723404974284","host":"s3://npm-registry-packages"}},"0.1.2":{"name":"classy-solid","version":"0.1.2","keywords":["components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.1.2","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"864d508f2e8653a68c7187f671a519b51c022f22","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.1.2.tgz","fileCount":55,"integrity":"sha512-oGZ4UErEpBJ0hwPnHAODXhzYzHAh7ei0j38psLosCncMEcXkkL+7nLAVloSx0dhgn6ca7U+XADBBzEMEiVEnwg==","signatures":[{"sig":"MEQCIFXRZFRxBagrOi/pOphVPA08O8x7mQJUsCxOay7gk28VAiAc4DglVjMZ6Iz8FTK2132+bUmJQr84vIRScmi9cwd/Qw==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":257248,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiUQuoACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmqNAw/+IenI0Wcp/OLgVbfJTPPtwMkJ8+UTTHa1a6GBWE1weq6yQtqp\r\nSq9Saw2uMC7MXJIlgipxtyF5zZ6u1VLrRmT24hcXN5pv7HxJ6ErlRXAiniPP\r\nVvHbag1B1GQx+qGSTDbJouaWVP/LJYUrC27vVgztilHP/+Db/tmHKwC2B4BX\r\nTjTecQ7c0Yyj+yA7LQazAeNdNFxeXHuIldj4M2c105s9NqgJOmDwLlfZd01m\r\nhcsnCs129Vxo0O6mx0BihSoy31dmRCMK+vuzpdHM9gm2JtgFZ8ULXSlLYnvX\r\n5zUdtGpgxXES6AOJpchu4vV0kEMU95aAjQScDmisk7wO4Jc5adDYlokQoZbA\r\n5vm3ZbmzTR9QZtPaEBtHdgk8lLRGbMUtKn1wkVES995N8H857oQ+r/fyqS0B\r\nnzSeZpC/2vrG5/J/43+9HIJAHuUWoC/sca3K/bLlt8CXOQfialXleeBTmzGv\r\nKHJP9jGwD+o4WLCT9z2nwJud2vvmaaWmDppgiCAxKXu6vJPLfJPlvgPYosxH\r\nuxMDghQJLbr2/iq65/xU2yeBsjEOS6O8kR1thzlSXpiMOVSZdlkBVUVFZrv1\r\n3Cziy2EjyTo1n+qEHlt+NPrc8iAwcLNFSh3QuVsNiCXKQTsthc/FcTEbP0eV\r\nv0hdTGw3n+fbcOVMXG7vNkRfeGZApUz5Lxg=\r\n=3zt1\r\n-----END PGP SIGNATURE-----\r\n"},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"4b87b9b3927ff24254b6eaa36ed48c025fd33e3b","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.3.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.3.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.7.0","typescript":"4.4.3"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.1.2_1649478568162_0.4452795027567378","host":"s3://npm-registry-packages"}},"0.1.3":{"name":"classy-solid","version":"0.1.3","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.1.3","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"ceaaa4d832a70cce47bb710aa21215188011e0fc","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.1.3.tgz","fileCount":55,"integrity":"sha512-mCOl+8oEf7R2tyGwTP4UIiEwYFpBQj7OcGaoYgoVyEob3BdiPhg6mfsu+vjca4QfyPqjDp+kcY6pTpBqWm1eJw==","signatures":[{"sig":"MEQCIH66cmzeLyKUPrTIHz0PA7KSjiyvfPvOGtU4gD4kTwlVAiB3xJjxHr4r2KUGJ5LbMbhrBzWdXGwn99X0ugKUModxuA==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":256316,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJip6x8ACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmqTXQ//Y67EIsglNXMRePRIaJ2cN4UkIhNEb6/8LNp1CcI+Cf7jDj3a\r\nELa69F3QR06sMdmp6nD8E+5/0hJkQ3uztyXQE8SxpIB66EipqCKwxiu9ahvn\r\n1M/dCCP1G7phn6GaoWIFUa8HADqHUAV90Hg6hvq94CBB/NlS5qUUVpRHC/Oj\r\nvHyb5UMTNc2sk4R90VbTpiX7rLnoONJNtF7ChGMClutLR4BYI2NyZwdcOVzE\r\nCLNiw7XcIjm+rCwYsPHVaCEyFcDb9/d1aJjx1iBuwQNEJb6agns6bRqhZApr\r\nlMZNRq5Txg/8NyPP1buVB5dz9maZBMvss7lZlWQhY+cXzc8ybkupnqz2OSPT\r\nXxfHiUibVpXcJYiDGFNxtfsvuM6/TeotDBjANBVcNKSjx/PVGL4t5LJGWNLC\r\nGvNvd8wAOI0LT5nlyUP5R9oRgZDBkoHTeTAOoHx9UjQ9POWuJSRQwHVQXr3K\r\na2KJL0AU/rUQ0eD1veykJ1wR3mHnzjCkj7asgYuw1jDYj87hN+ZkIwpyNi1e\r\n9uoZKefRP38yFccJkqeL3xgx9mRBKCUWYalMR6ag9PQbCE6K/X39+4I/mz5E\r\npBp07nXH/rCaFt31Xfh5ABz1g1icwTHILGfRK8ibyjUdWZM56r824l1ftDtg\r\n/eauRsoZevMfUc/QteKul++OccVBYM3dhCA=\r\n=yCsh\r\n-----END PGP SIGNATURE-----\r\n"},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"ac8202902e5fe570deddfc39ba67ee5ea1508464","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.6.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.3.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.8.0","typescript":"4.7.3"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.1.3_1655155836746_0.5868383814332672","host":"s3://npm-registry-packages"}},"0.1.4":{"name":"classy-solid","version":"0.1.4","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.1.4","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"89cc6b0df556098c46a8abffc3b7e111652d42b7","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.1.4.tgz","fileCount":55,"integrity":"sha512-j9Of56bNIuDOXHwEmLo+NJNlXWjtnQtxoUmW0mNjWzESe17ZaIyk5JFre1I7M7iexCJGtjWLpsa5AkQF975CXQ==","signatures":[{"sig":"MEUCIAWOuFR0j2B3FsB6ECzqhSyKFJsiRVOUPMiAI1gxHvHjAiEA+8/qjy8sxBJ5nkK70fIzShuiVZTTNLu6XGQ0bEvqB+U=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":259254,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJip9R8ACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmqJmg/+KnpAc5v/OdeAph18f+yTBth2dwoKmVqHlMBke6fBtJvRUT9H\r\nz74topJttZJAj5pHriGiIqf0EprYUWFtl6UUZLZ+PPgo8Ev/rTe1GiabPjLz\r\nCh3RCJRGYa5JE58HxWthPOe4VTdppwOCjKLgmixorR93gZ1maIx4d3RyL9tX\r\nMOreoZ5OK+/oYgxzgREW6m07pHX1m89K83ap7gQ4WJNfBvnHHFFMrMN2yMNY\r\nZnMkVdwTVjPhw8nrqlF4XbvM4x2rNPv3UlfteYluL8gwFb/N3edubrv1jMB+\r\nUzOGYmdMXu/NWYy+D2FTcHFFsWi3B0yUwimtrijOMXnKITMtvShF+yGLoJux\r\neC0gJchV3YwzW8SD0eOM7viccc+aL2VsaW9H1xUAtNgl+pPh8s4juMIuJHyp\r\n1Sq4V5dBWis3dp96khSMBG1WhlAjh12G5lhsu13d5j+kPZIw63K4T4r8LO1t\r\n8XxTHMDCrCoMi/vMaLjaYO8rh2jPO2uVwG36RWhuxCxNlsvHHga5JISXUwlS\r\nWouG5kE80DGJB3q+QXHlOkaiYvnciJWf6YNRM8BwPyzlz7OPCWKn5mH341Jg\r\nV1aqRDRoF560cWJsUNqlT4IxtpNM15vEVPRRe/4benMajE7V/9BDWsq9eaZt\r\nT6zC/BzjGA4iOIfP5tJHnrccW2zw3k7xucw=\r\n=ozzu\r\n-----END PGP SIGNATURE-----\r\n"},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"380382162c03bf64f7bf9946a700f5a00b5f8dc4","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.6.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.3.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.8.0","typescript":"4.7.3"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.1.4_1655166075867_0.5734309162410101","host":"s3://npm-registry-packages"}},"0.2.0":{"name":"classy-solid","version":"0.2.0","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.2.0","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"494814be754b0c80072f261db7adedf7ac1a8559","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.2.0.tgz","fileCount":70,"integrity":"sha512-Sg8PEMSJBkQtnyQQg01Lz/Ae1Eq+KXpOw/hNsDLNb5IfD63ZvoCBG+YFcnyoX3NfdlZ73UPrGVdUwin7a0Yecg==","signatures":[{"sig":"MEYCIQDOP+Zb/FkBGJ08M6KmblUZLAtS0JeVO6aX9dzyeTc3mAIhAK519UYzxsOeG+D/inegLVM/kJkSECEyk+C7JbB5JikR","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":319449,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJjP9fGACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpJ7g/8DIhk3TL+7f2vPgrCB0a2wvwHV65zvxcEQRPfAIW1EUfV8QRo\r\n4nZMxWFrs9xPaAfxEOmmknyTSdnpP+EQBYGDPv/Ukng8PflCR+NQ5kLq6e8D\r\nIJeToDxA3ZVm3VccWFLWaFsUB/OeEIKEwJhksesjR9oVrf5IqrSlyf6AldlF\r\nXrpcIsRydqONHTf1LxkTZhOaVYMlBIpdnL0INLQ631s537UErNlco3e9Z8MY\r\nk90JGEcKRqmAiQRnCZpZedLwBHGBoPPCO2Qmju0mXRmv3AGt8eGwZeDHdc0C\r\nbKyu9ajDnE8l6huIlF6OL3iJCKJplZgp4hu8nwJ0/gA21ADzqbyumDuCUVIL\r\ninMBSpbFkApk5/RNmnqqSpfwgTm/ltl7+YJSMJCktnOgPnd4aN0y9tt4qVOO\r\n5dOm5a1eZ5nNYdcTKLV7ahkhA4YAzAynfvBVWZXIdaVssXMHmSm8oIf5wc8I\r\nv8kdt75WyaOhbB0ltgp3HVqqAyAj5MHiUJAcgbQuRLXUV0VSb8wgT+O5PDd/\r\nJqFYi7pKsrVirMonpChq7NFjwJLPve56Pe4dfaVQkJKNGCnADD4dsj0nFhx0\r\nB85SIRLq7CkFOnU6dUlY22D/zU/ZQPU+UIvlMcBfJvIBRiy0aVK7wC8rQmQB\r\nEf1wVZ//G6N8U5c1n7qeWMuO7TNW953VOO8=\r\n=1kwL\r\n-----END PGP SIGNATURE-----\r\n"},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"b1c4a6077ad7e90cc39702e4efde759b3878bd50","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"live-server . --open=example","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.19.1","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"17.9.1","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.10.0","typescript":"^4.6.3","live-server":"^1.2.2","lit-dom-expressions":"^0.34.12"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.2.0_1665128389779_0.7284628502800248","host":"s3://npm-registry-packages"}},"0.2.1":{"name":"classy-solid","version":"0.2.1","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.2.1","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"e359e31404938cab8924dc8e144c50779b38bef6","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.2.1.tgz","fileCount":70,"integrity":"sha512-Sg27KnjmsextUowcqZ2JIXpsUg39qV8Pa20Y8al5TiUFvkcJCKwjkgFt24ZTD9lU/Zn4ezlsm5kHZCYazxvEVg==","signatures":[{"sig":"MEUCIQDHJw5XYgYSZ0TpsvmVpN8RYP6ruSkBQI/tAAbg0lxySQIgUhVGIBYKDSZybZ7lQEef0JhT1RjVz563etKll9RxQio=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":273679,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJjtnLAACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmq2/A/9FBSy4HIFPBF+SQbOmmGDD6JmshFSkdS4a8JZTvEmwGFqSMCw\r\nCu0OJzSy6lD/5bA2vFEV1q8AjqNmYP5Yy2tRyEfFfsG68SjFyZrt/uQOin1N\r\nRJ4xmkRcCI+8j50VaQYiob8aXW7E4ym1dGqgIMJyXUTX9ZzWyfoMT8a+Rg6R\r\nYFEYSGgKQNPgC2o0kEjTupfgFD3JNUTJGr9ZunU5EJVwJ7g+WfbAHFHemcH+\r\nxbjUtxoqTMvy0AgD3qlAStuIwjHNATsp0Y9TmYL2+w2R7DVN47gOY5GGSIxN\r\nsuuof6vDKg8AnqveZRVUe3psoadoQdeed30sQ2s1hrBpa/YLEExWxdWc/nP4\r\nf8chyZx074qLcMDM4DXx10lbolveTdHOxukibas0fF7we0OM8lUCX5Ir3boU\r\njLS/TuaIhAvWMJWP0qkp9vOiDFq36khzvy062/i7Eb2E6kpkxdGyp49ACtP6\r\nfZUyGz41mOZw1mKXCJzc7hlptjHFcHf7affB7Tot6jM6L9iwz57h1pCkM2tD\r\nowy6xEYXywShN8EzogPspbhRdi0tf1/rxRQDXJhXQipuyUGs46a+kmox0+74\r\nfJBIzIuQVccaMWhDdIZXuQCgZeiMqdv3VH/amhlgzgeS2EEHCjZS2uIkFbci\r\niIrs3q0m/q7l8tKWnZ8K5qywh8BG+umx95Y=\r\n=G19p\r\n-----END PGP SIGNATURE-----\r\n"},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","gitHead":"9499f276fd48cb7b993328f595a92c1c558cda8b","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"live-server . --open=example","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"8.19.3","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"18.12.1","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.10.0","typescript":"^4.6.3","live-server":"^1.2.2","lit-dom-expressions":"^0.34.12"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.2.1_1672901312586_0.9650436194152534","host":"s3://npm-registry-packages"}},"0.2.2":{"name":"classy-solid","version":"0.2.2","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.2.2","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"4d50f5ca785e517244459a6bf861f784ece3d50e","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.2.2.tgz","fileCount":70,"integrity":"sha512-MLYfayAFTLl6zsRq/NsyOz+VNhhM1neJHKPhlF9pVtzrLqDfMAeUZdqo+QU3HoxsB73617ozW+E2ZsGCwyOiTg==","signatures":[{"sig":"MEUCIExMAkQVe+zeistd/WYJRCeY7Op2BtUzm5qgAiohdtHAAiEA176ZSmAoUvmY6Gf3QRMoRL7hFLTDuvX/WPGUcWN+7Yo=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":334836},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"live-server . --open=example","prepare":"npm run build","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"9.8.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"18.13.0","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.10.0","typescript":"^4.6.3","live-server":"^1.2.2","lit-dom-expressions":"^0.34.12"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.2.2_1693035703932_0.2841368770729178","host":"s3://npm-registry-packages"}},"0.2.3":{"name":"classy-solid","version":"0.2.3","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.2.3","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/variable/issues"},"dist":{"shasum":"939358688e165a4988d9ca9a47ef2e9852c1519d","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.2.3.tgz","fileCount":70,"integrity":"sha512-dwQyhdhQsVg1KOHG8Az0Ehy7AhZfx1tTYpnGsDNOj6ZdhAr9UkEpKM02W5kkaVKTYmR1i4VIiS+WGZngzyngoA==","signatures":[{"sig":"MEQCIDIQ4m9FQVbtPP1SIXbEFTi+JJUpQdXikF8N1PNwZcSHAiAcHgpENy37Jn68FXw2CQ4cO0Wi6WB6qzG6qhiUMiyHUg==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":288996},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:debug":"lume testDebug","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.1.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^5.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"^2.0.0","@lume/cli":"^0.10.0","typescript":"^4.6.3","five-server":"^0.3.1","lit-dom-expressions":"^0.34.12"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.2.3_1695749660501_0.8651425838317903","host":"s3://npm-registry-packages"}},"0.3.0":{"name":"classy-solid","version":"0.3.0","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.0","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"970cbc5f20c5be4c1343e907504897e4dc00490e","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.0.tgz","fileCount":68,"integrity":"sha512-yKR286W+RWsnYf8QTNK6j6xM0eDcDY08VKktP/PDNxhiDO+2ES3KPCVWJV4zg6GzoMMdX93PpHMwzAnVZqySoA==","signatures":[{"sig":"MEUCIA6Mc3Rus9H5F2x/2k25s+e82epqnmvKh48wfVLA8fwQAiEA47ZiAtvS3y54rPSEP0X03PLQNRIG1zl/PEpwuH2rZIw=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":134001},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.10.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.0_1700257226065_0.8843968133812432","host":"s3://npm-registry-packages"}},"0.3.1":{"name":"classy-solid","version":"0.3.1","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.1","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"8759d77a8df1485f003052669a4d4bb9bb7f9e20","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.1.tgz","fileCount":68,"integrity":"sha512-pw1Dc5pOHs+WCTg2iF5J9VbhLAAESIYC3j2u/iPw1pRx6DWgWA/LgkM5dARu30wKUii+rEASwwzEoE0VUR/7EQ==","signatures":[{"sig":"MEUCIAxbkFcb9+MfH6EZlbtfCm3zGFT2JeSWPQuAUigZ74LPAiEA4Xw+8fTIcufqmYare87o/BbdMUarn/UL2sEb5d42iDs=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":140818},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.10.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.1_1700556297914_0.30746947076597997","host":"s3://npm-registry-packages"}},"0.3.2":{"name":"classy-solid","version":"0.3.2","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.2","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"5c4767f79d882e5d5997666f244f150aaf4b8540","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.2.tgz","fileCount":68,"integrity":"sha512-gXOQmHXGSNXlUMSC176CJiox8/BMYx19TuU81affbqqdgj2BgwxGkkb4PhKktBJQutAo8DbED4yhPmwuEzmEHA==","signatures":[{"sig":"MEYCIQDBB/cy/N0eJ0ZywfuyXzqguzeni+gsM/jk2IJR64xR3AIhAMMK/koxGy7X4nt6Wg0hM8mooXpNwg2SkorjrkZLE+Y2","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":149386},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.2_1701148348020_0.3591161312897915","host":"s3://npm-registry-packages"}},"0.3.3":{"name":"classy-solid","version":"0.3.3","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.3","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"408425507f4d5a92bb78713c047ac2ea8af40ee8","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.3.tgz","fileCount":68,"integrity":"sha512-fAcf2biLJmWhbUwtZuj9ZjzYips2kioJzd6MMWbpwS7gpa2/HxDZtebINZLkNeGuZPNjVvAbKYWCCx9DaZBPYQ==","signatures":[{"sig":"MEYCIQCpNWWq/wITcd1A4Cig45QFKTjz4NMncxNEXactUeDTFAIhAP2DHXDcxg3dq9H7PIdRtpJZaFU8c8dqudZzv3Gccu7H","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":149455},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.3_1701148541233_0.08853534829091947","host":"s3://npm-registry-packages"}},"0.3.4":{"name":"classy-solid","version":"0.3.4","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.4","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"79cd66ac419537abcc40fcd04288408f59c5eb02","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.4.tgz","fileCount":68,"integrity":"sha512-CnrGl5m6knKFKb9ce7CvoAQ0nEq4lM4CRJRMlVT8Aixw3lW0Px65v9/kZ2fBQB+yNGu7X2NeaPze/QhC9boqSQ==","signatures":[{"sig":"MEQCIGC0RdtID9jgeBwGrvFnFnao4RzCYoLFi+YVldCa+xFRAiA2jrI47RGtRqEnoBNpc4ix6RJgWGMJMF52G1fyRcG6dw==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":146451},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.4_1701241465178_0.041137531127976024","host":"s3://npm-registry-packages"}},"0.3.5":{"name":"classy-solid","version":"0.3.5","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.5","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"8dcb5525363a26bd1376b8414b236fc8a0f51e70","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.5.tgz","fileCount":68,"integrity":"sha512-K1xVw99VqsqdCtlOqP6rMt8U7d9kPVFtDYghtXu6LuxK1VX93ZFAlrQ0wGM6PSxx2fa9xzrsrlJZNenLEPARgw==","signatures":[{"sig":"MEUCIHbud3Tc+K/y7Fnodb7LrBkzwxFAKMaaoEHtU9n6ZwFqAiEAlX6EcV/ROKJ6PZQbMPQpOAh51JT4JzavERAp60XzE1Q=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":145400},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.4","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.5_1702531355267_0.08307536656742331","host":"s3://npm-registry-packages"}},"0.3.6":{"name":"classy-solid","version":"0.3.6","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.6","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"be22764db5092d1a344ab840d0b5b6e07a6f3051","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.6.tgz","fileCount":68,"integrity":"sha512-r96So5rpcXzcsOSi2V9Xt4NODUP01U+pomSI8kWOTQ+T44wdK3J2ncFiyLudDQM38LWMr4xKpckYHJmlbpm0qA==","signatures":[{"sig":"MEYCIQDN2ZHxSgTlqiUQ4fay9zYj9RZNqCqgurmBlyJuOIB73wIhAIWP/LwQLDtw8bdOszF4vo36cYA2sZjagPX9WZwBhrQV","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":145832},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.4","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.6_1702770137411_0.9844559798862942","host":"s3://npm-registry-packages"}},"0.3.7":{"name":"classy-solid","version":"0.3.7","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.7","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"ad3b2502e1f2dbb9f23861ee3fb08dc8585d6419","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.7.tgz","fileCount":83,"integrity":"sha512-0faSW+AQG6OSRm2s3JW6jH2Ti25Wjc9JBB3+Ka0PmUX0JGBSuiWSyRI0Vt4GVja+xCrsXwaJyQjgQZj62lDYfw==","signatures":[{"sig":"MEUCIQDbmcs2zYGdHEXs/+YIrhiRuF2JjBSSVdDVMCx1cDcMfAIgfLwJnQIU9TovH5xOcgtrx78v/qR2+tzgbvcX1VDBKT0=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":171908},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.2.4","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^7.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.7_1703404579768_0.19258328789356938","host":"s3://npm-registry-packages"}},"0.3.8":{"name":"classy-solid","version":"0.3.8","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.8","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"eb388a4d17fa616315b090422f6d50ea4a094bd0","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.8.tgz","fileCount":83,"integrity":"sha512-xKEpJkKsaBmecdfKoiCD1eIAcFhIsc0BhmkmaVwB2889kWcNk/cTtBXXiPCPhNLSnAdw6icn0Qcmx8MVVNGyUg==","signatures":[{"sig":"MEQCIDhtpnLsSinH5ztvwFgTObeOWDm2WkyYpnCVJAhhTYeNAiBq40m3pnX0P8s5YWSe6BWs1xkUTwryIMLqQCRMILI4tQ==","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":172277},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.11.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.8_1726106831030_0.5162017618726686","host":"s3://npm-registry-packages"}},"0.3.9":{"name":"classy-solid","version":"0.3.9","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.3.9","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"c8741912766960e83134bca737233be0740a8089","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.3.9.tgz","fileCount":83,"integrity":"sha512-QVAERy8PtkA2eozU/XCCeLamaokprPlCYS5Q7gK05eeE5/gCmIuiGV1F9SMurLpnVy9w6ZKSnNjxUd69btorzQ==","signatures":[{"sig":"MEYCIQCQ1KPC3FgirmA3J8Sd4wvQLRdEZqPtPpz/iq3apBB/awIhAMVGv9RDxdoztfGilQglmt+Z+kDCFHerTOPse8iC2hf0","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":171292},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.13.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.3.9_1726598276567_0.9128714883140083","host":"s3://npm-registry-packages"}},"0.4.0":{"name":"classy-solid","version":"0.4.0","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.4.0","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"0ee35d20be5e81d7d60f0caf09fd4eaa83e5ee1e","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.4.0.tgz","fileCount":98,"integrity":"sha512-JzgouA/7oS1ME1CqM6nATXapBpRLRKoRJNRgYMicF3y+TrO6V6mpcqgJUDXDIhNDmQ/CkhLz7FY82fqiYxUHag==","signatures":[{"sig":"MEUCIQDRJxF1zlWqvJBJ28vNmaAvHuztBa57h1m9rq1stiDX3gIgFLM1IAPuYsys0DRFkyVcnKuy8SO/Tj3vWXoT1N1yWK4=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":180848},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.13.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.4.0_1727302849064_0.2180166399685306","host":"s3://npm-registry-packages"}},"0.4.1":{"name":"classy-solid","version":"0.4.1","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.4.1","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"61a73e6b51f173a1c4dc15b4e3df940a51fe5659","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.4.1.tgz","fileCount":98,"integrity":"sha512-5GDmBsILqIAs+f7nsg6GHvwI/w2Yzt/Kut4ZhVit9oXfAX45ZgX1W/wRG3OvbyystNexn+N5jqspNZYz/Q+KgQ==","signatures":[{"sig":"MEUCICbJ8vAEdb+eCKgCpWPdgOZ2ZOvej/3WzTaqx5kitRmqAiEAj9LgRSsdDeWEp4OgxiqRyd9CRqWeWHhKp98YY7m/PW8=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":180647},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.13.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.4.1_1727303168634_0.3706281413989396","host":"s3://npm-registry-packages"}},"0.4.2":{"name":"classy-solid","version":"0.4.2","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.4.2","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"6b39679f153da65f1434bcc370c03f4cb3597ad0","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.4.2.tgz","fileCount":98,"integrity":"sha512-dGT0gWObBK7PeIbuxQBpatRprOKCZx+eH6g1khNFrAqUch+EA6EL72AOVE8qImlMYLnnTBVC5Dg+OdoRVCm6SQ==","signatures":[{"sig":"MEUCIHN6QcDn6MwNtPIy3KrotRhCZw3oS5fqYF3+MnwMLPGDAiEA29dApB8otYtSbsWoFvBk4dxe1B6dbN/B8Is8+hixn/0=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":180633},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.13.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.4.2_1727407539743_0.10954475012081","host":"s3://npm-registry-packages"}},"0.4.3":{"name":"classy-solid","version":"0.4.3","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.4.3","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"f49fa9518f3c746248b5e35e0e900167347e1aca","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.4.3.tgz","fileCount":98,"integrity":"sha512-mJ76piJ1+E5XAfMVk+29Y0rMs7UeXTjdANTX5oYpM9e23Zy+acYRBUfdg00kLTjp0Lm0mW/yh/HKmSyTvTPlFQ==","signatures":[{"sig":"MEYCIQCAvF1N1f5EXcerQ71ZB5HoZwOl36jk4DAErqJkN2OT4wIhAOgYZIdKepYATa792lemvsUX5g6UZQdgRM+aC0RzpWHs","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":181120},"info":"The `classy-solid` package gives you a `@signal` decorator to make reactive class properties, an `@component` decorator to use classes as Solid components, and some other APIs to simplify usage of reactive patterns in classes. It is still early, more features and changes to come!","main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.5.2","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"20.6.1","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.14.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.4.3_1729107055943_0.020369638955454183","host":"s3://npm-registry-packages"}},"0.4.4":{"name":"classy-solid","version":"0.4.4","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.4.4","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"8014583329f744220d9f448444ca3e75e7bc7ca5","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.4.4.tgz","fileCount":113,"integrity":"sha512-AVLh3MDtAo9ijVgTF9tx2AjPIP/YREcthsaN8btHjisi2GA92Ku4AIrabmtxIgGCEndOh+wIzWaBHqALso6NVA==","signatures":[{"sig":"MEQCIGtvSZTeW1jQdgTjCdWQJeqjLPm6No9lW5EhMcRGjHgyAiBJB5rO6dYnUcqkftQz9f9CiGAKJ0qam3G4cgtST24KlA==","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":259734},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.9.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"23.2.0","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13","@solid-primitives/memo":"^1.4.3"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.14.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.4.4_1764010377728_0.24841409271860804","host":"s3://npm-registry-packages-npm-production"}},"0.5.0":{"name":"classy-solid","version":"0.5.0","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.5.0","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"e366e52cb99dd2cff7f8eb0ca93cc5fd722071a9","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.5.0.tgz","fileCount":123,"integrity":"sha512-PufgJjDZbzNHmwBlarv7GxhmlUh3VBNKyYLSKAENyz+XMuvYNQ/GYYP/wLpwaOu/1vur3Ag3PgUu6AI+lR56Zg==","signatures":[{"sig":"MEQCIB6qrGYl3jSFRgalL6z+icxHbailcYrUj+ixmzapZ/QJAiAzVs45Zhj5cGOHiiMOr8+H0utsN/LlxqDkLD0eDII0rA==","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":312849},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.9.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"23.2.0","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13","@solid-primitives/memo":"^1.4.3"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.14.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.5.0_1765703991996_0.5824866211944244","host":"s3://npm-registry-packages-npm-production"}},"0.5.1":{"name":"classy-solid","version":"0.5.1","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","_id":"classy-solid@0.5.1","maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"contributors":[{"url":"https://lume.io","name":"Joe Pea","email":"trusktr@gmail.com"}],"homepage":"http://github.com/lume/classy-solid#readme","bugs":{"url":"https://github.com/lume/classy-solid/issues"},"dist":{"shasum":"c58f8febe990aaccd3b1d0bdfe2a1305476dcdf6","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.5.1.tgz","fileCount":123,"integrity":"sha512-WKaz04U/EbVktaMGoOqHbwuOeXxjoal4OZCCtgLdFTrx5k1DAsXDTDgdaNbTLYtcuQKsP2mfQEFzMtoMeBtLRg==","signatures":[{"sig":"MEYCIQDWRY36FwD2F0dUugFNKbhQkT5J+uA2BKLgTcmQgvsSTAIhAJRPgVY9WxaWO5vGslfvY8WwETrak59KGI+qnBoSX2Tg","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":350316},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","scripts":{"dev":"lume dev","test":"lume test","build":"lume build","clean":"lume clean","example":"five-server . --open=example","version":"lume versionHook","prettier":"lume prettier","typecheck":"lume typecheck","test:watch":"lume test --watch","postversion":"lume postVersionHook","release:major":"lume releaseMajor","release:minor":"lume releaseMinor","release:patch":"lume releasePatch","prettier:check":"lume prettierCheck","typecheck:watch":"lume typecheckWatch","LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":""},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"repository":{"url":"git+ssh://git@github.com/lume/classy-solid.git","type":"git"},"_npmVersion":"10.9.0","description":"Solid.js reactivity patterns for classes, and class components.","directories":{},"_nodeVersion":"23.2.0","dependencies":{"lowclass":"^8.0.0","solid-js":"^1.3.13","@solid-primitives/memo":"^1.4.3"},"_hasShrinkwrap":false,"devDependencies":{"prettier":"3.0.3","@lume/cli":"^0.14.0","typescript":"^5.0.0","five-server":"^0.3.1"},"_npmOperationalInternal":{"tmp":"tmp/classy-solid_0.5.1_1767175233880_0.6668247425856564","host":"s3://npm-registry-packages-npm-production"}},"0.5.2":{"name":"classy-solid","version":"0.5.2","description":"Solid.js reactivity patterns for classes, and class components.","author":{"name":"Joe Pea","email":"joe@trusktr.io"},"contributors":[{"name":"Joe Pea","email":"trusktr@gmail.com","url":"https://lume.io"}],"license":"MIT","homepage":"http://github.com/lume/classy-solid#readme","type":"module","main":"dist/index.js","// main":"The 'main' field is fallback for legacy Node.js that has no type:module support, otherwise Node 13.2+ ignores it if type:module is set.","types":"dist/index.d.ts","scripts":{"LUME SCRIPTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX":"","clean":"lume clean","build":"lume build","dev":"lume dev","typecheck":"lume typecheck","typecheck:watch":"lume typecheckWatch","test":"lume test","test:watch":"lume test --watch","prettier":"lume prettier","prettier:check":"lume prettierCheck","release:patch":"lume releasePatch","release:minor":"lume releaseMinor","release:major":"lume releaseMajor","version":"lume versionHook","postversion":"lume postVersionHook","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX OTHER SCRIPTS":"","example":"five-server . --open=example"},"dependencies":{"@solid-primitives/memo":"^1.4.3","lowclass":"^8.0.0","solid-js":"^1.3.13"},"devDependencies":{"@lume/cli":"^0.14.0","five-server":"^0.3.1","prettier":"3.0.3","typescript":"^5.0.0"},"repository":{"type":"git","url":"git+ssh://git@github.com/lume/classy-solid.git"},"bugs":{"url":"https://github.com/lume/classy-solid/issues"},"keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"_id":"classy-solid@0.5.2","_nodeVersion":"23.2.0","_npmVersion":"10.9.0","dist":{"integrity":"sha512-DCYFAiWqQr6VSO2s8iAaVOnnpTILjVoL3SR+4gTZQiXReKBi+5+px34Hp93JWN3IFP6VfuFk2hEPHYpSHgkuUA==","shasum":"793912d24a7de1f7d8c831ab005ee88f78a75124","tarball":"https://registry.npmjs.org/classy-solid/-/classy-solid-0.5.2.tgz","fileCount":123,"unpackedSize":365634,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEUCIEE9SIwsQdlXGMXrtJs+ptZpUskluzd2ndyaWfXZE197AiEAiN6/HV9kOll+8o5J2EXVuktgjnydmBpABPGWbkQc6C8="}]},"_npmUser":{"name":"trusktr","email":"joe@trusktr.io"},"directories":{},"maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/classy-solid_0.5.2_1767549652747_0.24689063827562774"},"_hasShrinkwrap":false}},"time":{"created":"2022-04-03T03:17:53.777Z","modified":"2026-01-04T18:00:53.097Z","0.1.0":"2022-04-03T03:17:54.049Z","0.1.1":"2022-04-08T06:31:36.209Z","0.1.2":"2022-04-09T04:29:28.340Z","0.1.3":"2022-06-13T21:30:36.968Z","0.1.4":"2022-06-14T00:21:16.091Z","0.2.0":"2022-10-07T07:39:49.999Z","0.2.1":"2023-01-05T06:48:32.739Z","0.2.2":"2023-08-26T07:41:44.109Z","0.2.3":"2023-09-26T17:34:20.838Z","0.3.0":"2023-11-17T21:40:26.236Z","0.3.1":"2023-11-21T08:44:58.080Z","0.3.2":"2023-11-28T05:12:28.224Z","0.3.3":"2023-11-28T05:15:41.490Z","0.3.4":"2023-11-29T07:04:25.387Z","0.3.5":"2023-12-14T05:22:35.425Z","0.3.6":"2023-12-16T23:42:17.611Z","0.3.7":"2023-12-24T07:56:19.965Z","0.3.8":"2024-09-12T02:07:11.297Z","0.3.9":"2024-09-17T18:37:56.760Z","0.4.0":"2024-09-25T22:20:49.287Z","0.4.1":"2024-09-25T22:26:08.821Z","0.4.2":"2024-09-27T03:25:39.974Z","0.4.3":"2024-10-16T19:30:56.177Z","0.4.4":"2025-11-24T18:52:57.936Z","0.5.0":"2025-12-14T09:19:52.160Z","0.5.1":"2025-12-31T10:00:34.040Z","0.5.2":"2026-01-04T18:00:52.900Z"},"bugs":{"url":"https://github.com/lume/classy-solid/issues"},"author":{"name":"Joe Pea","email":"joe@trusktr.io"},"license":"MIT","homepage":"http://github.com/lume/classy-solid#readme","keywords":["solidhack","best_ecosystem","components","dep tracking reactivity","dep-tracking-reactivity","lume","reactive coding","reactive computation","reactive programming","reactive variables","reactive","reactive-coding","reactive-computation","reactive-programming","reactive-variables","reactive-effects","reactivity","solid","solid-js","solid.js","solidjs","true-reactivity","ts","typescript","web-components"],"repository":{"type":"git","url":"git+ssh://git@github.com/lume/classy-solid.git"},"description":"Solid.js reactivity patterns for classes, and class components.","contributors":[{"name":"Joe Pea","email":"trusktr@gmail.com","url":"https://lume.io"}],"maintainers":[{"name":"trusktr","email":"joe@trusktr.io"}],"readme":"# <img src=\"./logo/Favicon_Classy.svg\" height=\"32\" /> Classy Solid <!-- omit in toc -->\n\nUtilities for making `class`es reactive with [Solid.js](https://solidjs.com)\nsignals, and for using `class`es as Solid.js components.\n\n![](https://github.com/user-attachments/assets/f091e629-7752-4a1a-808c-8672c1da072c)\n\n# Table of Contents <!-- omit in toc -->\n\n- [At a glance](#at-a-glance)\n- [Install](#install)\n  - [Vite Setup](#vite-setup)\n  - [Babel Setup](#babel-setup)\n- [API and Usage](#api-and-usage)\n  - [Decorator APIs](#decorator-apis)\n    - [`@signal`](#signal)\n    - [`@memo`](#memo)\n    - [`@effect`](#effect)\n    - [`@untracked`](#untracked)\n    - [`@component`](#component)\n      - [JavaScript with build tools](#javascript-with-build-tools)\n      - [JavaScript without build tools](#javascript-without-build-tools)\n      - [Accessing the class instance with `ref`:](#accessing-the-class-instance-with-ref)\n      - [TypeScript definition](#typescript-definition)\n      - [Type-safe refs in TypeScript:](#type-safe-refs-in-typescript)\n    - [`@reactive` (deprecated)](#reactive-deprecated)\n  - [Non-decorator APIs](#non-decorator-apis)\n    - [`component()`](#component-1)\n    - [`createSignalObject()`](#createsignalobject)\n    - [`createSignalFunction()`](#createsignalfunction)\n    - [`signalify()`](#signalify)\n    - [`memoify()`](#memoify)\n    - [`Effectful`](#effectful)\n    - [`Effects`](#effects)\n    - [`syncSignals`](#syncsignals)\n    - [`createSyncedSignals`](#createsyncedsignals)\n    - [`createStoppableEffect`](#createstoppableeffect)\n  - [Error Handling and Caveats](#error-handling-and-caveats)\n    - [Writable Memo Overrides](#writable-memo-overrides)\n    - [Static Fields](#static-fields)\n    - [Memory Considerations](#memory-considerations)\n\n# At a glance\n\n```jsx\nimport {render, batch} from 'solid-js'\nimport {component, signal, memo, effect, stopEffects} from 'classy-solid'\n\n//////////////////////////////////////////////////\n// Make plain classes reactive with Solid signals.\n\nclass Counter {\n\t@signal count = 0\n\t@signal num = 10\n\n\t@memo get #sum() {\n\t\treturn this.count + this.num\n\t}\n\n\t@effect #logCount() {\n\t\t// Log the count whenever it changes.\n\t\tconsole.log(`Count is: ${this.count}`)\n\t}\n\n\t@effect #logSum() {\n\t\t// Log the sum whenever it changes.\n\t\tconsole.log(`Sum is: ${this.#sum}`)\n\t}\n\n\tincrement() {\n\t\tthis.count++\n\t}\n}\n\nconst counter = new Counter()\n\nsetInterval(() => counter.increment(), 1000)\n\ncounter.count = 5 // Logs \"Count is: 5\" and \"Sum is: 15\"\ncounter.num = 20 // Logs \"Sum is: 25\"\n\n// After the batch function runs, logs \"Count is: 10\", but does not log \"Sum is:\n// 25\" because the sum did not change (@memo prevents effects from running\n// unnecessarily on the same values).\nbatch(() => {\n\tcounter.count = 10\n\tcounter.num = 15\n})\n\n// ...later, clean up when done...\nstopEffects(counter)\n\n//////////////////////////////////////////////////\n// Optionally use classes as Solid components.\n\n@component\nclass MyComp {\n\t@signal message = 'Hello, World!'\n\t@signal name = 'Asa'\n\n\ttemplate() {\n\t\tsetTimeout(() => (this.message = 'Hello after 3 seconds!'), 3000)\n\n\t\treturn (\n\t\t\t<div>\n\t\t\t\t<h1>{this.message}</h1>\n\n\t\t\t\t<p>My name is {this.name}.</p>\n\n\t\t\t\t<p>The count is: {counter.count}</p>\n\t\t\t</div>\n\t\t)\n\t}\n}\n\nrender(() => <MyComp name=\"Joe\" />, document.body)\n```\n\nSee the [live example](https://rawcdn.githack.com/lume/classy-solid/84a66ba70924f7a534792910aaeace3f594ff1db/example/index.html) and its [source code](https://github.com/lume/classy-solid/blob/84a66ba70924f7a534792910aaeace3f594ff1db/src/example.ts).\n\n# Install\n\n#### `npm install classy-solid` <!-- omit in toc -->\n\n> **Note** If you do not have or do not wish to use a build tool, see the\n> [Without compiler support](#without-compiler-support) section for plain\n> JavaScript usage without decorators.\n\n> **Note** `classy-solid` works only with the latest stage-3 decorators. Legacy\n> decorators are no longer supported, as we've moved onto the official decorator\n> format finally blessed by the TC39 EcmasScript language design committee.\n\n## Vite Setup\n\nUsing `classy-solid` with Vite may result in the following error because\ndecorators are not yet released natively into JavaScript engines (but they will\nbe soon!). For now, a Babel configuration must be provided to compile the syntax\nfor decorators.\n\n```\nSupport for the experimental syntax 'decorators' isn't currently enabled\n```\n\nTo use `classy-solid` with Vite (or [Solid Start](https://start.solidjs.com/getting-started/what-is-solidstart)), we need to set up the Babel configuration for\nthe Solid.js Vite plugin. First run the following:\n\n```\nnpm install --save-dev @babel/plugin-proposal-decorators\n```\n\nThen update your `vite.config.js` to use the Babel plugin:\n\n```js\n// ...\nsolidPlugin({\n\tbabel: {\n\t\tplugins: [['@babel/plugin-proposal-decorators', {version: '2022-03'}]],\n\t},\n})\n// ...\n```\n\n## Babel Setup\n\nSimilar to the Vite Setup above, you'll specify in your\n[Babel config file](https://babeljs.io/docs/en/configuration)\nthe same `@babel/plugin-proposal-decorators` plugin.\n\n```js\n// ...\nplugins: [['@babel/plugin-proposal-decorators', {version: '2022-03'}]]\n// ...\n```\n\n# API and Usage\n\nNote, these docs assume you have basic knowledge of [Solid.js](https://solidjs.com) first.\n\n## Decorator APIs\n\n### `@signal`\n\nDecorate a property (field, getter/setter, or auto accessor) of a class with\n`@signal` to make it reactive (i.e. backed by a Solid signal).\n\n```js\nimport {signal} from 'classy-solid'\nimport {createEffect} from 'solid-js'\n\nexport class Car {\n\t// field\n\t@signal engineOn = false\n\n\t// auto accessor\n\t@signal accessor sound = 'vroom'\n\n\t#speed = 0\n\n\t// getter/setter\n\t@signal get speed() {\n\t\treturn this.#speed\n\t}\n\t@signal set speed(value) {\n\t\tthis.#speed = value\n\t}\n\n\t// Alternatively, put the signal on the private field, depending on your\n\t// needs:\n\t// @signal #speed = 0\n\t// get speed() {\n\t// \treturn this.#speed\n\t// }\n\t// set speed(value) {\n\t// \tthis.#speed = value\n\t// }\n}\n```\n\n```js\nimport {Car} from './Car'\n\nconst car = new Car()\n\ncreateEffect(() => {\n\t// This re-runs any time car.engineOn or car.sound change.\n\tif (car.engineOn) console.log(car.sound, 'at speed', car.speed)\n\telse console.log('engine off')\n})\n\n// ...\n```\n\n### `@memo`\n\nUse this on a class property (getter/setter, auto accessor, or method) to create\na memoized derived value (readonly or writable) whose computation is cached and\nonly triggers effects when one of its reactive dependencies (f.e. `@signal` / `signalify`\nproperties) changes AND the computed value actually changes. This prevents\nunnecessary effect executions when dependencies change but the derived result\nstays the same.\n\nAlways prefer memos over effects for derived values, even if the value always\nchanges, as it is more semantic to express derived values as memos.\n\nMemo properties internally use Solid's `createMemo`/`createWritableMemo`\ndepending on the member form and function arity.\n\nSupported member forms:\n\n| Form                     | Example                                                 | Call Style                | Writable? | Rule                                   |\n| ------------------------ | ------------------------------------------------------- | ------------------------- | --------- | -------------------------------------- |\n| Getter                   | `@memo get sum() { return this.a + this.b }`            | `ex.sum`                  | No        | Getter w/o matching setter => readonly |\n| Getter + Setter          | `@memo get sum() { ... }` & `@memo set sum(v) {}`       | `ex.sum` / `ex.sum = 20`  | Yes       | Getter + (empty) setter => writable    |\n| Accessor (auto) readonly | `@memo accessor sum = () => this.a + this.b`            | `ex.sum()`                | No        | Arrow fn arity 0 => readonly           |\n| Accessor (auto) writable | `@memo accessor sum = (_v?: number) => this.a + this.b` | `ex.sum()` / `ex.sum(20)` | Yes       | Arrow fn arity > 0 => writable         |\n| Method readonly          | `@memo sum() { return this.a + this.b }`                | `ex.sum()`                | No        | Method arity 0 => readonly             |\n| Method writable          | `@memo sum(_v?: number) { return this.a + this.b }`     | `ex.sum()` / `ex.sum(20)` | Yes       | Method arity > 0 => writable           |\n\nAll forms work with public or private (`#private`) members.\n\nWritable memos: Setting a writable memo (e.g. `ex.sum(20)` or `ex.sum = 20`)\noverrides the current derived value. Subsequent dependency changes resume normal\nrecomputation. Readonly memos throw if you attempt to set them.\n\nArity rules: A function value (for auto accessors or methods) with length 0\nbecomes a readonly memo. A function value with length > 0 becomes writable. For\ngetter/setter pairs, the presence of an empty setter marks the memo writable.\nNote, do not provide a non-empty setter, it is ignored.\n\nExample:\n\n```ts\nclass Counter {\n\t@signal a = 1\n\t@signal b = 2\n\n\t// readonly getter memo\n\t@memo get sum() {\n\t\treturn this.a + this.b\n\t}\n\n\t// writable method memo\n\t@memo diff(_override?: number) {\n\t\treturn this.a - this.b\n\t}\n}\n\nconst c = new Counter()\ncreateEffect(() => console.log('sum:', c.sum)) // logs only on value change\ncreateEffect(() => console.log('diff:', c.diff()))\n\nc.a = 5 // sum recomputes (7), diff recomputes (3)\nc.diff(100) // override writable memo (diff now 100)\nc.a = 6 // diff recomputes again (6 - 2 = 4)\n```\n\nIn JS without decorators, use `signalify()` + `memoify()` manually:\n\n```js\nclass Counter {\n\ta = 1\n\tb = 2\n\n\tget sum() {\n\t\treturn this.a + this.b\n\t}\n\n\tdiff = () => this.a - this.b\n\n\tconstructor() {\n\t\tsignalify(this, 'a', 'b')\n\t\tmemoify(this, 'sum', 'diff')\n\t}\n}\n\nconst c = new Counter()\n\n// ... same usage as above ...\n```\n\nGotchas:\n\n- Methods and fields that become memo functions need to be invoked (`ex.sum()`),\n  whereas getters are accessed via property access (`ex.sum`).\n- Readonly memos should not be assigned; doing so throws.\n\n### `@effect`\n\nDecorate a method or auto accessor (with a function value) with `@effect` to\nautomatically create a Solid.js effect for it. The effect runs during\ninstantiation and re-runs whenever any reactive dependencies (signals or memos)\naccessed within it change.\n\n**Purpose:** Simplifies reactive side effects by eliminating the need to\nmanually call `createEffect()` in constructors or methods. Pair with `@signal`\nand `@memo` to create reactive classes with minimal boilerplate.\n\n**Use cases:**\n\n- Logging or debugging reactive state changes.\n- Side effects like network requests, DOM manipulation, or event subscriptions.\n\n**Cleanup:** Effects are tied to the class instance. Use:\n\n- `stopEffects(instance)` - standalone function to dispose all effects on an instance.\n- `instance.stopEffects()` - when extending `Effectful(BaseClass)` or `Effects`.\n\nIf the instance is created within an existing Solid owner (root, component,\neffect), effects are disposed automatically when that owner cleans up, and\n`stopEffects()` calls are unnecessary and will be a no-op.\n\n**Restart effects:** If you've stopped effects on an instance and want to restart\nthem, use:\n\n- `startEffects(instance)` - standalone function to restart all effects on an instance.\n- `instance.startEffects()` - when extending `Effectful(BaseClass)` or `Effects`.\n\n**Supported forms:**\n\n- **Method** (recommended): `@effect methodName() { ... }`\n- **Auto accessor**: `@effect accessor name = () => { ... }`\n\nBoth forms work with public or private (`#private`) members. Private effects are\nrecommended, as people typically shouldn't rely on calling public methods to\ntrigger logic that should already be automatic.\n\n**Example with `stopEffects()` and `startEffects()`:**\n\n```ts\nimport {effect, signal, stopEffects, startEffects} from 'classy-solid'\nimport {createSignal} from 'solid-js'\n\nconst [a, setA] = createSignal(1)\n\nclass Counter {\n\t@signal count = 0\n\n\t// Method form (recommended)\n\t@effect #logSum() {\n\t\tconsole.log('Sum:', a() + this.count)\n\t}\n\n\t// Auto accessor form (not recommended, only to keep any possibly pre-existing code as-is)\n\t@effect accessor #logCount = () => {\n\t\tconsole.log('Count:', this.count)\n\t}\n}\n\nconst counter = new Counter() // logs \"Sum: 1\", \"Count: 0\"\n\nsetA(5) // logs \"Sum: 5\"\ncounter.count = 10 // logs \"Sum: 15\", \"Count: 10\"\n\n// Later, clean up when done\nstopEffects(counter)\n\nsetA(8) // does not log anything\ncounter.count = 20 // does not log anything\n\n// Later, restart effects\nstartEffects(counter) // logs \"Sum: 28\", \"Count: 20\"\n\nsetA(2) // logs \"Sum: 22\"\n```\n\n**Example with [`Effectful`](#effectful) / [`Effects`](#effects) mixin:**\n\n```ts\nimport {effect, signal, memo, Effects} from 'classy-solid'\nimport {createSignal} from 'solid-js'\n\nconst [a, setA] = createSignal(1)\n\n// Extending from the Effectful(), or the non-mixin shortcut Effects class, give\n// us the stopEffects method. In this case, use `obj.stopEffects()` instead of\n// `stopEffects(obj)`.\nclass Counter extends Effects {\n\t@signal count = 0\n\n\t// Example: this memo is private, used only within the class.\n\t@memo get #sum() {\n\t\treturn a() + this.count\n\t}\n\n\t// Example: this effect is private, used only within the class.\n\t@effect #logSum() {\n\t\tconsole.log('Sum:', this.#sum)\n\t}\n}\n\nconst counter = new Counter() // logs \"Sum: 1\"\n\nsetA(5) // logs \"Sum: 5\"\ncounter.count = 10 // logs \"Sum: 15\"\n\nbatch(() => {\n\tcounter.count = 7\n\tsetA(8)\n}) // Does not log anything because sum did not change.\n\n// Later, clean up when done\ncounter.stopEffects()\n\nsetA(2) // does not log anything\ncounter.count = 20 // does not log anything\n\n// Later, restart effects\ncounter.startEffects() // logs \"Sum: 22\"\n\nsetA(3) // logs \"Sum: 23\"\n```\n\n**Why `@effect` over manual `createEffect()`?**\n\n- Less boilerplate (no constructor needed).\n- Declarative: effects defined inline with the properties they affect.\n- Automatic lifecycle management when used with `Effectful` or `Effects`.\n\nWithout decorators:\n\n```js\nimport {signalify, Effects} from 'classy-solid'\nimport {createSignal} from 'solid-js'\n\nconst [a, setA] = createSignal(1)\n\nclass Counter extends Effects {\n\tcount = 0\n\n\tget sum() {\n\t\treturn a() + this.count\n\t}\n\n\tlogSum() {\n\t\tconsole.log('Sum:', this.sum)\n\t}\n\n\tconstructor() {\n\t\tsignalify(this, 'count')\n\t\tmemoify(this, 'sum')\n\t\tthis.createEffect(this.logSum.bind(this))\n\t}\n}\n\nconst counter = new Counter()\ncounter.stopEffects() // when done\n```\n\n**Integrate with classess that have life cycle methods:**\n\nFor example, with Custom Element classes:\n\n```js\nimport {effect, signal, startEffects, stopEffects} from 'classy-solid'\nimport {externalState} from './hypothetical-app-state.js'\n\nclass MyElement extends HTMLElement {\n\t@effect #logCount() {\n\t\tconsole.log('Value is now:', externalState.value)\n\t}\n\n\tconnectedCallback() {\n\t\t// Start effects when element is added (or re-added) to DOM.\n\t\tstartEffects(this)\n\t}\n\n\tdisconnectedCallback() {\n\t\t// Stop effects when element is removed from DOM (if the element will not be\n\t\t// used again and is unreferenced, effects are garbage collected).\n\t\tstopEffects(this)\n\t}\n}\n\ncustomElements.define('my-element', MyElement)\n```\n\n**Preventing auto-start with `static autoStartEffects`:**\n\nBy default, effects created with the `@effect` decorator start immediately when\nan instance is constructed. You can prevent this by setting a static\n`autoStartEffects` property to `false` on your class. This is useful when you\nwant to manually control when effects begin running, such as when deferring\neffect startup until a component is mounted or an element is connected to the\nDOM.\n\n```ts\nimport {effect, signal, Effects, startEffects} from 'classy-solid'\n\nclass Counter extends Effects {\n\t@signal count = 0\n\n\t// Prevent effects from auto-starting on construction\n\tstatic autoStartEffects = false\n\n\t@effect #logCount() {\n\t\tconsole.log('Count:', this.count)\n\t}\n}\n\nconst counter = new Counter()\n// Effects haven't run yet, so nothing is logged\n\n// Later, when you want effects to start:\nstartEffects(counter)\n// Now logs \"Count: 0\"\n\ncounter.count = 5 // logs \"Count: 5\"\n```\n\nThis pattern is particularly useful with custom elements:\n\n```ts\nimport {effect, signal, Effectful, startEffects, stopEffects} from 'classy-solid'\n\nclass MyElement extends HTMLElement {\n\tstatic autoStartEffects = false\n\n\t@signal data = null\n\n\t@effect #renderData() {\n\t\tconsole.log('Rendering:', this.data)\n\t}\n\n\tconnectedCallback() {\n\t\t// Start effects only when element is in the DOM\n\t\tstartEffects(this)\n\t}\n\n\tdisconnectedCallback() {\n\t\t// Stop effects when element is removed\n\t\tstopEffects(this)\n\t}\n}\n```\n\n### `@untracked`\n\nA class decorator that makes a class's constructor untracked, preventing signal\nreads during construction from being tracked by outer effects.\n\n**When to use:** Only needed if your constructor reads signal/memo values.\nWithout `@untracked`, such a constructor will track dependencies when it is\ninstantiated in an effect and will cause an infinite loop.\n\nExample:\n\n```js\nimport {untracked, signal} from 'classy-solid'\nimport {createEffect} from 'solid-js'\n\n@untracked\nclass Example {\n\t@signal count = 0\n\n\tconstructor() {\n\t\t// Reading this.count here won't be tracked by outer effects\n\t\tthis.count = this.count + 1\n\t}\n}\n\ncreateEffect(() => {\n\t// This effect won't track count reads in the constructor,\n\t// preventing infinite loops. It only runs once.\n\tconst example = new Example()\n\n\tcreateEffect(() => {\n\t\t// This inner effect DOES track count changes\n\t\tconsole.log(example.count)\n\t})\n})\n```\n\nWithout decorators:\n\n```js\nimport {untracked} from 'classy-solid'\n\nconst Example = untracked(\n\tclass {\n\t\tcount = 0\n\n\t\tconstructor() {\n\t\t\tsignalify(this)\n\t\t\t// Reading this.count here won't be tracked by outer effects\n\t\t\tthis.count = this.count + 1\n\t\t}\n\t},\n)\n\n// ... same usage as above ...\n```\n\n### `@component`\n\nA decorator that makes a `class` usable as a component within a Solid template\n(f.e. within JSX, or an `html` template tag).\n\nA class decorated with `@component` can optionally have any three of the\nfollowing methods:\n\n- `onMount` - Called after the the initial instantiation of the component, after\n  the `template` has been executed, just like Solid's\n  [`onMount`](https://www.solidjs.com/docs/latest/api#onmount).\n- `onCleanup` - Called when the component is removed, just like Solid's\n  [`onCleanup`](https://www.solidjs.com/docs/latest/api#oncleanup).\n- `template` - Returns a template (f.e. JSX markup), just like the return values\n  of a Solid function component, and it can use any reactive signal properties of\n  the class.\n\n> **Note** All props passed into a class component get mapped to class\n> properties, regardless if the property is reactive or not. This means you can,\n> for example, forgo the `@signal` decorator and use your own accessors to\n> handle changes in some other way as you wish, or use existing classes that\n> have properties implemented in their own way.\n\nExamples:\n\n#### JavaScript with build tools\n\nCurrently the best way to write JavaScript code with `classy-solid` is if you have a\nbuild setup in place (soon decorators will be native in JavaScript engines and a\nbuild step will not be necessary for decorators, but will still be necessary for\nJSX templates).\n\nThe [Babel](https://babeljs.io/) compiler, for example, allows use of decorators\nand JSX (not this example shows a variety of way to do things, but not all are\nrecommended, see the idiomatic example afterwards):\n\n```jsx\nimport {component, signal, memo, effect} from 'classy-solid'\nimport {onMount, onCleanup, createEffect} from 'solid-js'\n\nexport\n@component\nclass MyComp {\n\t@signal name = 'Anon'\n\t@signal count = 1\n\n\t#h1\n\n\tonMount() {\n\t\tconsole.log('onMount method, h1 element reference:', this.#h1)\n\n\t\tthis.int = setInterval(() => this.count++, 1000)\n\n\t\t// Clean up like this (recommended),\n\t\tonCleanup(() => clearInterval(this.int))\n\t}\n\n\t// or clean up like this.\n\tonCleanup() {\n\t\tclearInterval(this.int)\n\t}\n\n\t// Create memo properties on the class (backed by Solid createMemo).\n\t@memo get doubleCount() {\n\t\treturn this.count * 2\n\t}\n\t@memo set doubleCount(value) {\n\t\t// providing an empty setter makes this a writable memo (backed by createWritableMemo from solid-primitives)\n\t}\n\n\t// This effect is public (not recommended, if people need to rely on calling\n\t// it, something is wrong, effects should be solely dependent on reactive\n\t// state).\n\t@effect logDoubleCount() {\n\t\tconsole.log('Double count is now:', this.doubleCount)\n\n\t\t// nested effects\n\t\tcreateEffect(() => {\n\t\t\t/*...*/\n\t\t})\n\n\t\t// cleanup\n\t\tonCleanup(() => {\n\t\t\t/*...*/\n\t\t})\n\t}\n\n\ttemplate(props) {\n\t\t// The class is in a Solid reactive context. You can also use onMount or\n\t\t// other Solid APIs like usual. The template() method is a Solid\n\t\t// function component that has access to `this`. For example, the\n\t\t// following two lines of standard Solid code would work fine here:\n\t\tonMount(() => console.log('mounted'))\n\t\tcreateEffect(() => console.log('count:', this.count))\n\n\t\t// Here we show that passed-in `props` can be used directly. All\n\t\t// props are automatically mapped to same-name properties on the\n\t\t// class instance, which is why the passed in `count={}` prop is\n\t\t// also accessible as `this.count` above.\n\t\treturn (\n\t\t\t<h1 ref={this.#h1}>\n\t\t\t\tHello, my name is {this.name}! The count is {props.count}. The double count is {this.doubleCount}.\n\t\t\t</h1>\n\t\t)\n\t}\n}\n\nrender(() => <MyComp name=\"Joe Pea\" />, document.body)\n```\n\nThe above example shows a class component with multiple ways of doing things\n(not recommended!). When using class components, the most idiomatic practice is\nto use top level effects with `@effect`, and all state in the class with\n`@signal`/`@memo` without props via `template`:\n\n```jsx\nimport {component, signal, memo, effect} from 'classy-solid'\nimport {onCleanup} from 'solid-js'\n\nexport\n@component\nclass MyComp {\n\t@signal name = 'Anon'\n\t@signal count = 1\n\n\t#h1\n\n\t@memo get doubleCount() {\n\t\treturn this.count * 2\n\t}\n\n\tonMount() {\n\t\tconsole.log('onMount, h1 element reference:', this.#h1)\n\n\t\tthis.int = setInterval(() => this.count++, 1000)\n\t\tonCleanup(() => clearInterval(this.int))\n\t}\n\n\t@effect #logDoubleCount() {\n\t\tconsole.log('Double count is now:', this.doubleCount)\n\n\t\t// If this effect has anything to clean up:\n\t\tonCleanup(() => {\n\t\t\t/*...*/\n\t\t})\n\t}\n\n\ttemplate = () => (\n\t\t<h1 ref={this.#h1}>\n\t\t\tHello, my name is {this.name}! The count is {this.count}. The double count is {this.doubleCount}.\n\t\t</h1>\n\t)\n}\n\nrender(() => <MyComp name=\"David Base\" />, document.body)\n```\n\n#### JavaScript without build tools\n\nFor plain JS users without build setups or that prefer not using decorators or\nJSX, use `component`, `signalify`, and `memoify` via plain function calls, and\nuse Solid's [`html` template\ntag](https://github.com/solidjs/solid/tree/main/packages/solid/html) for\ntemplating because JSX requires compilation. Here's the same example as above\nbut without decorators or JSX:\n\n```js\nimport {component, signalify, memoify} from 'classy-solid'\nimport {onCleanup, createEffect} from 'solid-js'\nimport html from 'solid-js/html'\n\nconst MyComp = component(\n\tclass {\n\t\tname = 'Anon'\n\t\tcount = 1\n\n\t\t#h1\n\n\t\tget doubleCount() {\n\t\t\treturn this.count * 2\n\t\t}\n\n\t\tconstructor() {\n\t\t\t// Signalify all own properties, i.e. class fields.\n\t\t\tsignalify(this)\n\n\t\t\t// Or, to signalify specific properties only (see signalify() docs).\n\t\t\t// signalify(this, 'name', 'count')\n\n\t\t\t// Initialize memos (explicit mode because getters are not own properties).\n\t\t\tmemoify(this, 'doubleCount')\n\n\t\t\t// This will not work, because getters are not own properties:\n\t\t\t// memoify(this)\n\t\t}\n\n\t\tonMount() {\n\t\t\tconsole.log('h1 element:', this.#h1)\n\n\t\t\tthis.int = setInterval(() => this.count++, 1000)\n\t\t\tonCleanup(() => clearInterval(this.int))\n\n\t\t\tcreateEffect(() => this.logDoubleCount())\n\t\t}\n\n\t\tlogDoubleCount() {\n\t\t\tconsole.log('Double count is now:', this.doubleCount)\n\n\t\t\t// If this effect has anything to clean up:\n\t\t\tonCleanup(() => {\n\t\t\t\t/*...*/\n\t\t\t})\n\t\t}\n\n\t\ttemplate = () =>\n\t\t\thtml`<h1 ref=${el => (this.#h1 = el)}>\n\t\t\t\tHello, my name is ${() => this.name}! The count is ${() => this.count}. The double count is ${() =>\n\t\t\t\t\tthis.doubleCount}.\n\t\t\t</h1>`\n\t},\n)\n\nrender(() => html`<${MyComp} name=\"Tito Bouzout\" />`, document.body)\n```\n\n> **Note** The new decorators proposal reached stage 3, so JavaScript will have\n> decorators natively soon and won't require compiler support. JSX will still\n> require compilation.\n\nFor reference, here's the same example using the `component` decorator as a\nregular function, but with properties wired up to Solid signals and memos\nmanually, which is the equivalent of what the `@signal` and `@memo` decorators\n(or `signalify()` and `memoify()` functions) do under the hood for convenience,\nbut with a lot more boilerplate:\n\n```jsx\nimport {component} from 'classy-solid'\nimport {createSignal, createMemo, createEffect, onCleanup} from 'solid-js'\nimport html from 'solid-js/html'\n\nconst MyComp = component(\n\tclass MyComp {\n\t\t#name = createSignal('Anon')\n\n\t\tget name() {\n\t\t\t// read from a Solid signal\n\t\t\tconst [get] = this.#name\n\t\t\treturn get()\n\t\t}\n\t\tset name(value) {\n\t\t\t// write to a Solid signal\n\t\t\tconst [, set] = this.#name\n\t\t\tset(value)\n\t\t}\n\n\t\t#count = createSignal(1)\n\n\t\tget count() {\n\t\t\tconst [get] = this.#count\n\t\t\treturn get()\n\t\t}\n\t\tset count(value) {\n\t\t\tconst [, set] = this.#count\n\t\t\tset(value)\n\t\t}\n\n\t\t#h1\n\n\t\t#doubleCount = createMemo(() => {\n\t\t\treturn this.count * 2\n\t\t})\n\n\t\tget doubleCount() {\n\t\t\treturn this.#doubleCount()\n\t\t}\n\n\t\tonMount() {\n\t\t\tconsole.log('h1 element:', this.#h1)\n\n\t\t\tthis.int = setInterval(() => this.count++, 1000)\n\t\t\tonCleanup(() => clearInterval(this.int))\n\n\t\t\t// log doubleCount\n\t\t\tcreateEffect(() => {\n\t\t\t\tconsole.log('Double count is now:', this.doubleCount)\n\n\t\t\t\t// If this effect has anything to clean up:\n\t\t\t\tonCleanup(() => {\n\t\t\t\t\t/*...*/\n\t\t\t\t})\n\t\t\t})\n\t\t}\n\n\t\ttemplate = () =>\n\t\t\thtml`<h1 ref=${el => (this.#h1 = el)}>\n\t\t\t\tHello, my name is ${() => this.name}! The count is ${() => this.count}. The double count is ${() =>\n\t\t\t\t\tthis.doubleCount}.\n\t\t\t</h1>`\n\t},\n)\n\nrender(() => html`<${MyComp} name=\"Batman\" />`, document.body)\n```\n\n#### Accessing the class instance with `ref`:\n\nThe `ref` prop provides access to the actual class instance, similar to element\nrefs in Solid. This is useful for calling methods, accessing properties, or\nintegrating with imperative APIs.\n\n```jsx\nimport {component, signal} from 'classy-solid'\nimport {render} from 'solid-js/web'\n\n@component\nclass Counter {\n\t@signal count = 0\n\n\tincrement() {\n\t\tthis.count++\n\t}\n\n\ttemplate() {\n\t\treturn <div>Count: {this.count}</div>\n\t}\n}\n\nlet counterRef!\n\nrender(() => (\n\t<>\n\t\t<Counter ref={(instance) => (counterRef = instance)} />\n\t\t<button onClick={() => counterRef.increment()}>Increment</button>\n\t</>\n), document.body)\n```\n\nThe `ref` callback is called with the class instance after it's created, after\n`onMount` runs. You can use it to store a reference, call methods, or pass the\ninstance to other parts of your app.\n\n#### TypeScript definition\n\nTypeScript supports decorators out of the box with no additional setup needed.\n\n> **Note** The same rules apply here as with decorators in the previous\n> JavaScript section, and the only difference here is added type checking.\n\n```tsx\nimport {component, signal, memo, Props} from 'classy-solid'\n\n@component\nclass MyComp {\n\t// Define `PropTypes` on your class to define prop types for JSX. Note, this\n\t// property does not actually need to exist at runtime and is not used at\n\t// runtime, so here we use the `declare` to tell TS not to assume it exists\n\t// for the sake of type checking.\n\t// Do not try to use this property at runtime!\n\tdeclare PropTypes: Props<this, 'name' | 'count'>\n\n\t@signal name = 'Anon'\n\t@signal count = 123\n\n\t// Example: this is private, used only within the class.\n\t@memo get #doubleCount() {\n\t\treturn this.count * 2\n\t}\n\n\t// This property will not appear in the JSX prop types, because we did not\n\t// list it in the `PropTypes` definition.\n\tfoo = 'blah'\n\n\t#h1: HTMLHeadingElement | undefined = undefined\n\n\ttemplate = () => (\n\t\t<h1 ref={this.#h1}>\n\t\t\tHello, my name is {this.name}! The count is {this.count}. The double count is {this.#doubleCount}.\n\t\t</h1>\n\t)\n}\n\nrender(() => <MyComp name=\"Robin\" count={456} />, document.body)\n```\n\n#### Type-safe refs in TypeScript:\n\n```tsx\nimport {component, signal, Props} from 'classy-solid'\n\n@component\nclass Counter {\n\tdeclare PropTypes: Props<this, 'count'>\n\n\t@signal count = 0\n\tincrement = () => this.count++\n\ttemplate = () => <div>Count: {this.count}</div>\n}\n\n// Then depending on what you are doing:\n\n// Use a ref in a class component, with class-based signal and effect\n@component\nclass Example1 {\n\t@signal counterRef: Counter | null = null\n\n\t@effect #log() {\n\t\tconsole.log(this.counterRef)\n\t}\n\n\ttemplate() {\n\t\treturn <Counter ref={(c: Counter) => (this.counterRef = c)} count={5} />\n\t}\n}\n\n// Use a ref in a function component\nfunction Example2() {\n\tlet [counterRef, setCounterRef] = createSignal<Counter>()\n\n\tcreateEffect(() => console.log(counterRef()))\n\n\treturn <Counter ref={setCounterRef} count={5} />\n}\n\n// Use a ref in a class component, in the template method like a component\n@component\nclass Example1 {\n\ttemplate() {\n\t\tlet [counterRef, setCounterRef] = createSignal<Counter>()\n\n\t\tcreateEffect(() => console.log(counterRef()))\n\n\t\treturn <Counter ref={setCounterRef} count={5} />\n\t}\n}\n```\n\n### `@reactive` (deprecated)\n\n**⚠️ DEPRECATED:** Use [`@untracked`](#untracked) instead. This decorator is no\nlonger needed for making `@signal` or `@memo` work. It now serves only as an\nalias to `@untracked` for backward compatibility.\n\n## Non-decorator APIs\n\n### `component()`\n\nThe [component](#component) decorator is also available as a regular function\nfor use in situations where decorators are undesired not yet supported. See the\n[JavaScript without build tools](#javascript-without-build-tools) section above\nfor an example.\n\n### `createSignalObject()`\n\nReturns a Solid signal in the form of an object with `.get` and `.set` methods,\ninstead of an array tuple.\n\n```js\nlet count = createSignalObject(0) // count starts at 0\ncount.set(1) // set the value of count to 1\ncount.set(count.get() + 1) // add 1\nlet currentValue = count.get() // read the current value\n```\n\nIn cases where decorators are not yet supported or undesired, using Solid's\n`createSignal` directly as a `class` property is not so ideal:\n\n```js\nclass Counter {\n\tcount = createSignal(0)\n\n\tincrement() {\n\t\t// These are not so readable:\n\t\tthis.count[1](this.count[0]() + 1)\n\t\t// or\n\t\tthis.count[1](c => c + 1)\n\t}\n}\n```\n\n`createSignalObject` provides an alternative that is more usable as a `class`\nproperty:\n\n```js\nclass Counter {\n\tcount = createSignalObject(0)\n\n\tincrement() {\n\t\t// These are more readable:\n\t\tthis.count.set(this.count.get() + 1)\n\t\t// or\n\t\tthis.count.set(c => c + 1)\n\t}\n}\n```\n\n### `createSignalFunction()`\n\nReturns a Solid signal in the form of a single overloaded function for both\ngetting and setting the signal, instead of an array tuple. Call the function\nwith no arguments to get the signal value, and call it with an arg to set the\nsignal value.\n\n```js\nlet count = createSignalFunction(0) // count starts at 0\ncount(1) // set the value of count to 1\ncount(count() + 1) // add 1\nlet currentValue = count() // read the current value\n```\n\nIn cases where decorators are not yet supported or undesired, using Solid's\n`createSignal` directly as a `class` property is not so ideal:\n\n```js\nclass Counter {\n\tcount = createSignal(0)\n\n\tincrement() {\n\t\t// These are not so readable:\n\t\tthis.count[1](this.count[0]() + 1)\n\t\t// or\n\t\tthis.count[1](c => c + 1)\n\t}\n}\n```\n\n`createSignalFunction` provides an alternative that is more usable as a `class`\nproperty:\n\n```js\nclass Counter {\n\tcount = createSignalFunction(0)\n\n\tincrement() {\n\t\t// These are more readable:\n\t\tthis.count(this.count() + 1)\n\t\t// or\n\t\tthis.count(c => c + 1)\n\t}\n}\n```\n\n### `signalify()`\n\nConvert properties on an object into Solid signal-backed properties. This is\nwhat [`@signal`](#signal) uses behind the scenes.\n\nUseful with plain objects and classes when decorators are unavailable or\nundesired.\n\n**Two modes:**\n\n1. **Explicit mode** (properties listed): Only the specified properties become\n   reactive signals.\n2. **Automatic mode** (no properties listed): All own enumerable properties\n   (string and symbol keys) become reactive, **except** function-valued properties,\n   which are skipped by default (use `signalify()` in explicit mode for those if\n   you need a signal with a function value, or use [`memoify()`](#memoify) to\n   create memo functions that return derived values).\n\n**Interplay with `memoify()`:** Call `signalify()` first to set up reactive\ndata properties, then call `memoify()` to set up derived memos that depend on\nthose signals. This mirrors the typical usage of `@signal` followed by `@memo`\nwhen using decorators.\n\nHere are some examples. Make certain properties on an object reactive\nsignal-backed properties:\n\n```js\nimport {signalify} from 'classy-solid'\nimport {createEffect} from 'solid-js'\n\nconst obj = {foo: 1, bar: 2, baz: 3}\n\n// Explicit mode: Make only the 'foo' and 'bar' properties reactive.\nsignalify(obj, 'foo', 'bar')\n\n// ...\n\ncreateEffect(() => {\n\tconsole.log(obj.foo, obj.bar)\n})\n```\n\nIn some cases, using `signalify` is more desirable than Solid's `createMutable`\nbecause the original object is not wrapped in a `Proxy`. This can be useful for\npatching 3rd-party objects to make them reactive, whereas it would not be\npossible with `createMutable`.\n\nNote, it returns the same object passed in, so you can write this:\n\n```js\n// Make only the 'foo' and 'bar' properties reactive (backed by Solid signals).\nconst obj = signalify({foo: 1, bar: 2, baz: 3}, 'foo', 'bar')\n```\n\n**Automatic mode** makes all properties signal-backed, omitting the property\nnames internally uses `Object.keys(obj)` (and `Object.getOwnPropertySymbols(obj)`):\n\n```js\n// Automatic mode: Make all properties reactive signals (except function-valued).\nconst obj = signalify({foo: 1, bar: 2, baz: 3, method() {}})\n// foo, bar, baz are now reactive. method() is skipped.\n```\n\nThe object passed in is the same object returned:\n\n```js\nlet test\nconst obj = signalify(test = {...})\nconsole.log(obj === test) // true\n```\n\nTo signalify function-valued properties, explicitly list them:\n\n```js\nconst obj = signalify({foo: 1, bar: 2, baz: 3, method() {}}) // foo, bar, baz only\nsignalify(obj, 'method') // now method is also signalified\n```\n\n**Why exclude methods by default?** Functions are typically computed/derived\nvalues best handled by [`memoify()`](#memoify) to avoid unnecessary reactivity\non static behavior, so `memoify()` will handle them by default. The\n`signalify()` function skips them by default to allow `memoify()` to handle\nthem, avoiding a conflict and making usage easy by default. Sometimes you may\nwant a function-valued signal, so you can list them explicitly in that case.\n\nSignalify properties in a class (alternative to decorators):\n\n```js\nimport {signalify} from 'class-solid'\nimport {createEffect} from 'solid-js'\n\nclass Counter {\n\tcount = 0\n\ton = true\n\n\tconstructor() {\n\t\t// Make only the 'count' variable reactive (signal-backed). The 'on'\n\t\t// variable remains a regular property.\n\t\tsignalify(this, 'count')\n\t}\n}\n\nconst c = new Counter()\n\n// ...\n\ncreateEffect(() => {\n\tconsole.log(c.count)\n})\n```\n\nThe downside of the previous example (namely, not using decorators) is that the\ncode is less [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself), we\nhad to repeat ourselves by writing the word \"count\" twice. But, if you're okay\nwith it, you can make all properties reactive by omitting the second arg\n(sometimes you don't want all properties to be reactive):\n\n```js\nclass Counter {\n\tcount = 0\n\ton = true\n\n\tmethod() {}\n\n\tconstructor() {\n\t\t// Both 'count' and 'on' will be signal-backed (method won't be):\n\t\tsignalify(this)\n\t}\n}\n```\n\nNote how with decorators, the code is more DRY and concise, because we don't\nhave to express the property names more than once, therefore reducing some surface\narea for human mistakes, and we don't have to write a `constructor`:\n\n```js\nclass Counter {\n\t@signal count = 0\n\t@signal on = true\n\n\tmethod() {}\n}\n```\n\n**Plain JS example combining `signalify()` and `memoify()`:**\n\nWithout decorators, you can achieve similar reactive behavior manually:\n\n```js\nimport {signalify, memoify} from 'classy-solid'\nimport {createEffect} from 'solid-js'\n\nconst counter = {\n\tcount: 0,\n\tnum: 10,\n\n\t// Computed value (will be memoified)\n\tget sum() {\n\t\treturn this.count + this.num\n\t},\n\n\tincrement() {\n\t\tthis.count++\n\t},\n}\n\n// Step 1: Make data properties reactive\nsignalify(counter, 'count', 'num')\n\n// Step 2: Turn computed properties into memos\nmemoify(counter, 'sum')\n\nsetInterval(() => counter.increment(), 1000)\n\ncreateEffect(() => {\n\tconsole.log(`Count is: ${counter.count}`)\n})\n\ncreateEffect(() => {\n\tconsole.log(`Sum is: ${counter.sum}`)\n})\n\ncounter.count = 5 // Logs \"Count is: 5\" and \"Sum is: 15\"\ncounter.num = 20 // Logs \"Sum is: 25\"\n```\n\nThis pattern (signalify first, memoify second) mirrors the decorator approach\n(`@signal` then `@memo`) and is ideal for plain objects or when decorators are\nnot available.\n\n### `memoify()`\n\nConvert function-valued properties or accessors on an object or instance into\nSolid memo-backed descriptors, enabling reactive derived computations without\ndecorators. Similar to [`signalify()`](#signalify) for signals.\n\nSignature:\n\n```ts\nmemoify(obj: object, ...props: (keyof typeof obj)[]): typeof obj\n// Automatic mode (no props): memoify all function-valued own keys & accessors.\n```\n\nBehavior:\n\n- Explicit mode (`memoify(obj, 'foo', 'bar')`): Only listed keys memoified.\n- Automatic mode (`memoify(obj)`): All own string & symbol keys; skips non-function values unless they are accessors (getter/setter).\n- Function arity 0 => readonly memo (`ex.sum()`).\n- Function arity > 0 => writable memo (`ex.sum()` and `ex.sum(20)`).\n- Getter only => readonly memo.\n- Getter + setter => writable memo (setter should be empty, it is symbolic only).\n- Already memoified or signalified getters are skipped.\n\nExamples:\n\n```js\nconst obj = {\n\ta: 1,\n\tb: 2,\n\n\t// readonly memo via method\n\tsum() {\n\t\treturn this.a + this.b\n\t},\n\n\t// Writable memo via accessor\n\tget diff() {\n\t\treturn this.a - this.b\n\t},\n\tset diff(v) {}, // Setter makes the memo writable\n}\n\nsignalify(obj, 'a', 'b')\nmemoify(obj, 'sum', 'diff')\n\ncreateEffect(() => console.log('sum:', obj.sum()))\ncreateEffect(() => console.log('diff:', obj.diff))\n\nobj.a = 5 // triggers both memos (sum=7, diff=3)\nobj.diff = 100 // overrides diff\nobj.a = 6 // diff recomputes (6 - 2 = 4)\n```\n\nAutomatic mode:\n\n```js\nconst calc = {\n\tx: 10,\n\ty: 5,\n\n\tproduct() {\n\t\treturn this.x * this.y\n\t},\n\n\tget ratio() {\n\t\treturn this.x / this.y\n\t},\n}\n\nsignalify(calc) // make x, y reactive\nmemoify(calc) // memoify product(), ratio\n```\n\nUse cases:\n\n- Plain objects needing derived reactive values without decorators.\n- ES5-style constructor/prototype patterns.\n- Memoizing expensive calculations (chained memos supported).\n\nWhen to prefer [`@memo`](#memo) vs `memoify()`:\n\n- Use [`@memo`](#memo) inside modern class syntax where decorators are supported.\n- Use `memoify()` for plain objects, prototypes, or when decorators are undesirable or not available.\n\nSee also: [`signalify()`](#signalify) for creating reactive data properties that\nmemos can depend on.\n\n### `Effectful`\n\n`Effectful` is a class-factory mixin that adds reactive effect management to\nany class. It provides:\n\n- `this.createEffect(fn)` - Creates a Solid effect tied to the instance.\n- `this.stopEffects()` - Stops all effects created via `createEffect()` on this instance.\n\n**Purpose:** Useful for classes that need to manage multiple effects with a\nsingle cleanup call, especially in component-like patterns (custom elements,\nlifecycle-driven classes, etc.).\n\n**Cleanup semantics:** Effects are created within a shared Solid.js owner root\nfor the instance. Calling `stopEffects()` disposes that root, stopping all\neffects. Subsequent `createEffect()` calls create a new root. Typically you\ncreate a class, then call `stopEffects()` when the instance is no longer needed\n(for example with Custom Elements, in `disconnectedCallback`).\n\n**Use cases:**\n\n- Custom elements with `connectedCallback` / `disconnectedCallback`.\n- Classes with explicit lifecycle methods (e.g., `start()` / `stop()`).\n- Any pattern where you want effects grouped and cleaned up when finished.\n\nHere's an example of a plain class extending Effectful, where effects are\ncreated and then the instance is later cleaned up (note how on `onCleanup` is\nused within an effect to clean up resources like intervals):\n\n```js\nimport {onCleanup} from 'solid-js'\nimport {signal, Effectful} from 'classy-solid'\n\nclass Counter extends Effectful(Object) {\n\t@signal count = 0\n\t@signal num = 10\n\n\tincrement() {\n\t\tthis.count++\n\t}\n\n\tconstructor() {\n\t\tsuper()\n\n\t\t// Create some effects\n\t\tthis.createEffect(() => {\n\t\t\tconsole.log('count:', this.count)\n\t\t})\n\n\t\tthis.createEffect(() => {\n\t\t\tconsole.log('num:', this.num)\n\t\t})\n\n\t\tthis.createEffect(() => {\n\t\t\tconst int = setInterval(() => this.increment(), 1000)\n\t\t\t// Cleanup interval when effects are disposed\n\t\t\tonCleanup(() => clearInterval(int))\n\t\t})\n\t}\n}\n\nconst counter = new Counter() // effects start\n\n// later, when finished with the counter...\ncounter.stopEffects() // effects stop\n```\n\nHere's an example with a custom element that starts effects on connected and\ncleans them up on disconnect:\n\n```js\nimport {onCleanup} from 'solid-js'\nimport {memo, signal, Effectful} from 'classy-solid'\n\nclass CounterDisplay extends Effectful(HTMLElement) {\n\tstatic {\n\t\tcustomElements.define('counter-display', this)\n\t}\n\n\t@signal count\n\n\t@memo get double() {\n\t\treturn this.count * 2\n\t}\n\n\tconstructor() {\n\t\tsuper()\n\t\tthis.attachShadow({mode: 'open'})\n\t\tthis.shadowRoot.innerHTML = `<div></div>`\n\t}\n\n\tconnectedCallback() {\n\t\t// Create some effects\n\t\tthis.createEffect(() => {\n\t\t\tthis.shadowRoot.firstElementChild.textContent = `Count is: ${this.count}`\n\t\t})\n\n\t\tthis.createEffect(() => {\n\t\t\tconsole.log('count:', this.count)\n\t\t})\n\n\t\tthis.createEffect(() => {\n\t\t\tconsole.log('double:', this.double)\n\t\t})\n\n\t\tthis.createEffect(() => {\n\t\t\tconst int = setInterval(() => this.count++, 1000)\n\t\t\t// Cleanup interval when effects are disposed\n\t\t\tonCleanup(() => clearInterval(int))\n\t\t})\n\t}\n\n\tdisconnectedCallback() {\n\t\t// Stop the effects, and clear them as new ones will be created on next\n\t\t// connect.\n\t\tthis.clearEffects()\n\t}\n}\n\nconst counterEl = document.createElement('counter-display')\ndocument.body.append(counterEl) // effects start\n\n// ...later, when removed from DOM...\ncounterEl.remove() // effects stop\n```\n\n> [!Note] Note\n> `createEffect()` creates a single owner root for all effects for the current\n> instance, unless it is called inside another root in which case it'll use that\n> root.\n\n**Deferred effect startup with `addEffectFn()`:**\n\nBy default, `createEffect()` immediately starts effects. In some cases, you may\nwant to add effect functions without starting them, and then start them all at\nonce later using `startEffects()`. The `addEffectFn()` method allows you to do\nthis:\n\n- `this.addEffectFn(fn)` - Adds an effect function to the instance without starting it.\n\n```js\nimport {onCleanup} from 'solid-js'\nimport {signal, Effectful, startEffects, stopEffects} from 'classy-solid'\n\nclass DeferredEffects extends Effectful(Object) {\n\t@signal count = 0\n\n\tconstructor() {\n\t\tsuper()\n\n\t\t// Add effects without starting them\n\t\tthis.addEffectFn(() => {\n\t\t\tconsole.log('count is', this.count)\n\t\t})\n\n\t\tthis.addEffectFn(() => {\n\t\t\tconst inter = setInterval(() => this.count++, 1000)\n\t\t\tonCleanup(() => clearInterval(inter))\n\t\t})\n\t}\n}\n\nconst deferred = new DeferredEffects()\n// No effects run yet\n\ndeferred.startEffects()\n// Now logs \"count is 0\" and starts interval incrementing count\n\ndeferred.count = 5\n// Logs \"count is 5\" and continues interval incrementing count\n\ndeferred.stopEffects()\n// Effects stop\n```\n\nThis is particularly useful when combined with `static autoStartEffects = false`\nand the `@effect` decorator. The above example can be rewritten like this:\n\n```js\nimport {onCleanup} from 'solid-js'\nimport {signal, Effectful, startEffects, stopEffects} from 'classy-solid'\n\nclass DeferredEffects extends Effectful(Object) {\n\tstatic autoStartEffects = false\n\n\t@signal count = 0\n\n\t@effect logCount() {\n\t\tconsole.log('count is', this.count)\n\t}\n\n\t@effect interval() {\n\t\tconst inter = setInterval(() => this.count++, 1000)\n\t\tonCleanup(() => clearInterval(inter))\n\t}\n}\n\nconst deferred = new DeferredEffects()\n// No effects run yet\n\ndeferred.startEffects()\n// Now logs \"count is 0\" and starts interval incrementing count\n\ndeferred.count = 5\n// Logs \"count is 5\" and continues interval incrementing count\n\ndeferred.stopEffects()\n// Effects stop\n```\n\n### `Effects`\n\nA pre-instantiated version of `Effectful(Object)`, providing the same API\nwithout requiring a mixin call, for convenience.\n\n**Purpose:** Use `Effects` when:\n\n- You don't need to extend a specific base class.\n- You want multiple independent effect groups within a single class.\n\n**When to choose `Effects` over `Effectful`:**\n\n- `Effectful(BaseClass)` - When you want effect management baked into your class hierarchy.\n- `new Effects()` - When you want a standalone effect manager or multiple independent groups.\n\nUseful when not need to extend a specific base class other than the default\n`Object`:\n\n```js\nclass MyClass extends Effects {\n    constructor() {\n        this.createEffect(() => {...})\n        this.createEffect(() => {...})\n    }\n\n    dispose() {\n        this.stopEffects()\n    }\n}\n\nconst o = new MyClass()\n\n// ...later, when finished...\no.dispose()\n```\n\nUseful when separate groups of effects are needed where each group can be stopped indepently of others.\n\n```js\nclass MyClass {\n    specialEffects = new Effects()\n    otherEffects = new Effects()\n\n    doSpecialStuff() {\n        this.specialEffects.createEffect(() => {...})\n        this.specialEffects.createEffect(() => {...})\n    }\n\n    cleanupSpecialStuff() {\n        this.specialEffects.stopEffects()\n    }\n\n    doOtherStuff() {\n        this.otherEffects.createEffect(() => {...})\n        this.otherEffects.createEffect(() => {...})\n    }\n\n    cleanupOtherStuff() {\n        this.otherEffects.stopEffects()\n    }\n}\n```\n\n### `syncSignals`\n\nSynchronizes two Solid signals bidirectionally: setting one updates the other,\nand vice versa, without causing an infinite loop.\n\n**Purpose:** Useful for keeping two separate signal sources in sync, such as:\n\n- Syncing a prop signal with internal state.\n- Bridging signals across component boundaries or libraries.\n- Maintaining consistency between derived/computed signals.\n\n**How it works:** Uses an internal tracking mechanism to detect when one signal\nchanges and propagate to the other, skipping redundant updates.\n\n**Signature:**\n\n```ts\nsyncSignals<T>(\n  getterA: Accessor<T>, setterA: Setter<T>,\n  getterB: Accessor<T>, setterB: Setter<T>\n): [[getterA: Accessor<T>, setterA: Setter<T>], [getterB: Accessor<T>, setterB: Setter<T>]]\n```\n\nExample:\n\n```js\nconst [foo, setFoo] = createSignal(0)\nconst [bar, setBar] = createSignal(0)\n\nsyncSignals(foo, setFoo, bar, setBar)\n\ncreateEffect(() => console.log(foo(), bar()))\n\nsetFoo(1) // logs \"1 1\"\nsetBar(2) // logs \"2 2\"\n```\n\nIt returns the getters/setters, so it is possible to also create the signals\nand sync them at once:\n\n```js\nconst [[foo, setFoo], [bar, setBar]] = syncSignals(...createSignal(0), ...createSignal(0))\n\ncreateEffect(() => console.log(foo(), bar()))\n\nsetFoo(1) // logs \"1 1\"\nsetBar(2) // logs \"2 2\"\n```\n\n### `createSyncedSignals`\n\nCreates two synchronized signals in one call.\n\n**Purpose:** Shorthand for creating and syncing signals simultaneously, reducing boilerplate.\n\n**When to use:**\n\n- You need two signals synced from the start with the same initial value.\n- You want cleaner code than manually calling `createSignal()` twice and then `syncSignals()`.\n\n**Signature:**\n\n```ts\ncreateSyncedSignals<T>(initialValue: T): [[Accessor<T>, Setter<T>], [Accessor<T>, Setter<T>]]\n```\n\nEquivalent to:\n\n```js\nconst [[foo, setFoo], [bar, setBar]] = syncSignals(...createSignal(0), ...createSignal(0))\n```\n\nExample:\n\n```js\nconst [[foo, setFoo], [bar, setBar]] = createSyncedSignals(0)\n```\n\n### `createStoppableEffect`\n\n⚠️ **Experimental** - Use with caution (see below).\n\nCreates a Solid effect that can be manually stopped via a `.stop()` method.\n\n**Purpose:** Provides fine-grained control over individual effects without\nneeding a parent owner root or manual disposal. Note, this is an experimental API\nbecause of potential memory management caveats (see below).\n\n**Signature:**\n\n```ts\ncreateStoppableEffect(fn: EffectFunction): { stop: () => void }\n```\n\nExample:\n\n```js\nconst effect = createStoppableEffect(() => {\n\t// ...\n})\n\n// ...later, stop the effect from running again.\neffect.stop()\n```\n\n**⚠️ Memory leak caveat:** When created inside a long-lived parent reactive\ncontext (e.g., app-level root), stopped effects **will not be garbage\ncollected** until the parent context is disposed. This can cause memory leaks\nif many effects are created and stopped over time.\n\n**Safe usage:**\n\n- Create outside reactive contexts (effects will GC freely after `.stop()`).\n- Use [`Effectful`](#effectful) or [`Effects`](#effects) if you need grouped cleanup.\n- Avoid creating many stoppable effects within a single long-lived root.\n\n**Why experimental?** Solid's ownership model doesn't yet support detaching\nchild computations from parent roots while preserving proper GC. This API may\nchange in future versions.\n\n## Error Handling and Caveats\n\n### Writable Memo Overrides\n\nSetting a writable memo overrides the computed value until dependencies change:\n\n```js\nclass Counter {\n  @signal a = 1\n  @signal b = 2\n  @memo sum(_v?: number) { return this.a + this.b }\n}\n\nconst c = new Counter()\nconsole.log(c.sum()) // 3 (computed)\nc.sum(100)           // Override to 100\nconsole.log(c.sum()) // 100 (overridden)\nc.a = 5              // Dependency changed\nconsole.log(c.sum()) // 7 (recomputed)\n```\n\n**Caveat:** Overridden values are **not persisted** across dependency changes.\nIf you need persistent overrides, use a separate signal to track the override\nstate.\n\n### Static Fields\n\n- **Static fields:** Not yet supported by `@signal` or `@memo`.\n\n### Memory Considerations\n\n- **Effects and Roots:** Effects created via [`Effectful`](#effectful) /\n  [`Effects`](#effects) are grouped under an owner root. Always call\n  `stopEffects()` when done to avoid memory leaks.\n- **Stoppable Effects:** See caveats in [`createStoppableEffect`](#createstoppableeffect).\n","readmeFilename":"README.md"}