{"_id":"@3d-dice/dice-roller-parser","_rev":"8-39683ba7263845a8e42613163d440983","name":"@3d-dice/dice-roller-parser","dist-tags":{"latest":"0.2.6"},"versions":{"0.1.9":{"name":"@3d-dice/dice-roller-parser","version":"0.1.9","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.0.1","@types/node":"^16.9.1","jest":"^27.2.0","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.0.5","ts-loader":"^9.2.5","tslint":"^6.1.3","typescript":"^4.4.3","webpack":"^5.52.1","webpack-cli":"^4.8.0"},"gitHead":"0c1420dc176380c05ed9f17624bbb06144cb8f53","_id":"@3d-dice/dice-roller-parser@0.1.9","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-Dddq0W2bddIMvLYit5fPaPpB4JEWLzykbOCBMR1M3c9OA5qXpy3CkOaK1eqGGkE7l+7mzdorA6uZIHcah8vqgA==","shasum":"5c6ba62ea5d19f5e810a9b6f2429785407f66524","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.1.9.tgz","fileCount":10,"unpackedSize":275502,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJhQM69CRA9TVsSAnZWagAAwfkQAJcY4EuHa0/HF8Y9S5MN\nePkNxI1xVFp/RvgVk6mVeTGj2fkjwfWNnNGggH3+wOuqfmhOAd88woZcPQSo\n/n9lY74Pc49q+1ZDd4wm71PyRxROzMgpkbYkkAbSsjQOpaIDFxq0Z98N+URz\nIzBEgUZZoLwdY7+8yWIEf0v4hM2VsJi71ZGd0BDCXN9aupgzZu9IdJD5EKFC\nnuJIobeFleYBqEIsD9ljNejwflv3aVJkTw6CvIDn7NOOUeRKFZQdujJuZEEc\nj7YS2v/YjIJu1cleLAA+n6DqowTsjGx/nJKB0oiq6DEPNnXPbTBC9r6J5KID\n1v7ZVCh7UzNSGqA8U+WsGdLMOW4l8R3yktGdoi4Lqxl2p5fte9toLC+QJ0ku\n8qDWJ/ZNp4tPTYJtZJWFtW7U5Opf/ISMw3ebUqtD+GVz9f6wWhIPsqhiqx38\nwXUt0xvZ1j88CTOZGE1lNKY2XNHkvNOstwd0Zt2LzclAN+Q5+wH05JEbarpj\nr7QcD880vMA2V2j+7z5NgTGEQBqAj7kKS7rDgDfj0hfLlGyFMOr9RURcnfp6\n9L9zvhQ7CUDRcOq10TVW30HGPcxTPyJ87xpKplPANaMsaM3SLay724EsZnf2\n3Ms50pjueicjXd/OSdnd34tnmrRBdNEjDKkMVvJlaWOgOqXpK3C2CgvfYLeY\n17La\r\n=9u/F\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCYZFUjcHHQRF2lq8K81ldt7QhPU1I7RH1h5ND5kgmvsQIhAMhituQnRU8zsmRC84tmntjjtzm6ndtjKnghOx2vSxSq"}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.1.9_1631637181696_0.84223630931789"},"_hasShrinkwrap":false},"0.2.0":{"name":"@3d-dice/dice-roller-parser","version":"0.2.0","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.0.1","@types/node":"^16.9.1","jest":"^27.2.0","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.0.5","ts-loader":"^9.2.5","tslint":"^6.1.3","typescript":"^4.4.3","webpack":"^5.52.1","webpack-cli":"^4.8.0"},"gitHead":"735b346ab20c38d7481e6945b92e695e025da65a","_id":"@3d-dice/dice-roller-parser@0.2.0","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-tCK5rf+ui+EE0K7dIeUFTReYh9AtGiKYXS0914XXl2HgOrRjwJ6sp20HjrI5zLhKgIfGhLrDdDcb0aWIUvjxVQ==","shasum":"916c7d95e0697efc6b20526b78d8472fc37b6849","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.0.tgz","fileCount":10,"unpackedSize":277022,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJhnw4ICRA9TVsSAnZWagAAEK0P/RHGXW6ZQbbbEt8rKIZS\nunRTOhXvQXxr9zPxh+TzJRi886OGLbSwSvHmDTeD3ICYHLco7SyohBtMQ8B0\nMuZQEJzwgY7yZOqdDqhmiuAkd7nmnzQ4I7MNChjxTxNldYYNjNsFF/0mhsAU\nNAeBMaypsk97bev+NUHAJNwYHNOjBUasRHITeATmcZs7wlW7B21I/mD/Y9Rk\nkukah7GFq3CQxr+3ULI6LbnWeS8PAUXXQCERZtAOFki/+HJIdR7DFpWk4zJT\najS0qtHqYBFPi4X2LTDBUpz9hL2zlupUbxkPq08WLJLEkYR4qnxxAoRhEClx\nWMGK9PvRZr+ty5vm6jQh8/94OZN2boktZe+sRo1bihonMes+hzHE8S/ruZeZ\nberXh7VJwPH5ka1Hg5hqyy2J/u354diVvZhAFTRCZXXOmGS9q0UPZvUvB8TZ\nIJjy+3FMbD2GMq9Z8GTMkFNHGFPUcU6rqV0KWjy3oTCTkKnmepPpv+FKYxHI\ng7x7Bs8FLRnWUoWTfk0mbgApNMowqmOMZGkw1ont5ydXhQXwaYE+RoxtQoOg\ncr51e0pzakZ90lu5TxyI2Kk6t+7W9FGqXslQyPUGzghIufI12tvboYnEJIik\nKZzechBHkb0ylraxOfLvuPM3WJZQjwUJ28u5KNLGKp1SYPOjjLJYp1ULLXze\n3xZi\r\n=jVsk\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCdFt9CaD36abRRBy8ima8e+QlcX4um8sMEaKXCZlXQ1gIgGE1CfatluXBUPXpI7EJJuU58zXvZK6SI+5KiArD2iwI="}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.0_1637813768665_0.4523258571833828"},"_hasShrinkwrap":false},"0.2.1":{"name":"@3d-dice/dice-roller-parser","version":"0.2.1","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.0.1","@types/node":"^16.9.1","jest":"^27.2.0","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.0.5","ts-loader":"^9.2.5","tslint":"^6.1.3","typescript":"^4.4.3","webpack":"^5.52.1","webpack-cli":"^4.8.0"},"gitHead":"da39eeb0164eb350e395e6d72a3ced2a32860215","_id":"@3d-dice/dice-roller-parser@0.2.1","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-GFHuAJhU36VR+w6PGBvq2Xwm1qPKYXra9vb2fZMqYGIsBXDqEmyOfoZTJBeFZAqRWRMktYsjLj8P/osEGVW+NQ==","shasum":"ebdd16fc250ecf60d36244a622b4c5880dbaad23","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.1.tgz","fileCount":10,"unpackedSize":277395,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJhnxS7CRA9TVsSAnZWagAAk3gP/iUQEdEaoD+oLgKTE1TI\nz9lgmqhZ+d75IZm7pMvuQlpF2CxCzgSjN+sQPhkgDG0t8vfz5XqoXqeZH6NV\n+RmTU9vf3BtWSurQQpKjFgmzW6FbPWkXu1+UVQIQSAnwV5GLMb67pxNv5H6R\nqTC4CvT+roHecea/Rwz8o2W5ByJykXZ1cin1ZW05RqAzpkWLtK5QG5epEs52\nVnAYB+S/XvPwT8cLqM1gHQkFQH4aiWO8eIyMsBDpmGzSFjplhe+/ZKVTZw4H\noHnPQtzDYJ6gRivJ0HFjoxHkzEeX3vBS7PT/7Z9uR5cyZt0HocoHlFsYLBeF\nWH2ndgVKx90LJkw9+BhOCARJsbR09e0v63+F9ySskJeTqO+D+mstd2jiGuvr\nf/lcpcGNY7WmpGJbFPsgz2UBpYkyplirqRpfEYQzJYe/b3QbgOQ2VaeW1mSa\nCWdI6Tt4Rdem74jZUSjb6lM2kK8sYyMSj5R1E7YmUyCeser10C/ABy3JNB2K\nBWCUakb8q8NrXA4XjGtwC4J8TKe2r9q5hPndUcMyciZCAto+2/Yh/02NITMC\nL/kDraCAmmoHzJiDzaov0pbUk1XyJa6x08Dqt8LQLJz9QQe65TDqRzGb9PRl\nCMhzeJwW4s7/FoNEiuWD3G0YtDe7RLq2vVuov3lHZBMnd2l3MJvMDJSlVME9\nXiwH\r\n=+ob1\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCn0Z/LD8O1sr4K8S4NxXp489FvW8bLfdtJuJoFuloNIgIgGPps7isp3gJESfvqPwvvcPwDdDomz9UnAQEuqAnoxYg="}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.1_1637815483568_0.720806870306985"},"_hasShrinkwrap":false},"0.2.2":{"name":"@3d-dice/dice-roller-parser","version":"0.2.2","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.0.1","@types/node":"^16.9.1","jest":"^27.2.0","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.0.5","ts-loader":"^9.2.5","tslint":"^6.1.3","typescript":"^4.4.3","webpack":"^5.52.1","webpack-cli":"^4.8.0"},"gitHead":"14683f61dc481570fcbc7f6c75ef84e480f15a8d","_id":"@3d-dice/dice-roller-parser@0.2.2","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-7bGpTYxJjvuxOOz+VEZ8uzMifNLaG5ITBO2kQU+SQXwS8jXHMh8FEoHlfztkEgE2BjC/8BLmIqCUOl3+RT5RJw==","shasum":"1e7190dc57931f8e29c3ad584bebdb4e4c1ab80a","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.2.tgz","fileCount":10,"unpackedSize":277466,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJhnxcACRA9TVsSAnZWagAA+gQP/3Vm8RzcyVR67MSBY17j\nCcS1y/vJa0IIHKjPU5D9LflTINJMr9atdj8YmvtIm1kOzSAxqQNPsf6BgRIS\nVTtgwn0C9THNijscmC8iIMtBUaHguDj8UW/W3TXNAi2EXqXm+2kdU2aSygAY\nhSL4UTkal7/yY1t9ZwH16N00Vybhz+PYDo59YBxVXNTrYL8/dRxIhpOPsSZJ\nzfcItXBEMzZ8kOqGioHzf4EXwxjhMwoFzLYjYLfrNfzRPtGsWg7Atcq2/rlK\nSpqZ6cFiffHAcy4yE3RdAX/ZVhKGAjU7vhd7Gva6FNyRP7MB7plMcatQbVYb\niGlcaKYhC53yfpyq0TojzNTTEsNjHTtvyn37p/Y+JFt10mk15lFvqssnqUtB\nPcSNTadtsVZH+6uGIk25xLkFYYE29Z+Jy+qxaIrd3jwVpoSgKm+hnh0lfa7m\njKihRcSqADjUIg8pdyfWP8UiOul4SPIs9BeBbl//X/BoPL7sFWDVRjGslJXN\nx8aX58trq87R6YShD6pvqhU/aZFqdLWD/2QRjC9RtNBaZrOjE6DwUqwz+qlu\nAQoPuaWIwGNrputFMkjq+370FXnY4pRJ2cPnBLAZNcgObgnqgNxvQtBU6Vhn\ngGh7xNBazjmrhPvfCMFD9YG54ujdlEmbr0RF0fwcdSL70VTBKCkwDTCbikXk\nWGeC\r\n=6cbT\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCrDv7tvH7ndZTjEl+PqovjlyTkTOEAfhp3TpP43aPN/wIhANewA1Cvwe2frmcJXgfoMIKU30QFNJYLxl0umlBuvtzP"}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.2_1637816064398_0.04395814730190106"},"_hasShrinkwrap":false},"0.2.3":{"name":"@3d-dice/dice-roller-parser","version":"0.2.3","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.0.1","@types/node":"^16.9.1","jest":"^27.2.0","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.0.5","ts-loader":"^9.2.5","tslint":"^6.1.3","typescript":"^4.4.3","webpack":"^5.52.1","webpack-cli":"^4.8.0"},"gitHead":"bea58bac83310d835ec608a1e643a24f4ce19209","_id":"@3d-dice/dice-roller-parser@0.2.3","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-ZuU1g4DaS4u8EGiCW50k4iUOfBK+gReL4geQh+UbpoTF2ViEgT/QKPeV3vIbLzfYEYvTI9s0l3KPsJPTZ3IU6g==","shasum":"c494552b12b50a0b8a608ed840bfc4b83e7db991","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.3.tgz","fileCount":10,"unpackedSize":277895,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJhnxijCRA9TVsSAnZWagAA3tAP/2yhxO7eeuw//1uKgwkZ\nU1Jal/ppwMGPFhaMvZiikOuaBSYj/BwZXJiAeuO/O9EoRz9ob/lSELgp3TXU\nBEuVTU6glJdXdIjCNdsMR9y08DeDxc/wTbBMwL27GCv9cWA1xtxUj2KcKu2M\nvTsK/wnkafq3ilFP22RYx3D+iyBaAuhCPtzOboiVLjUejkJ+uAwnkEiBlymB\nXZckQ2DEs1XeyVJgAauxz4Yt8/2gdEeNm79Aw+IHEM8Y9jD1MQif9LxLUMlc\nck7g8TJuvM/5enhKa2ic87Wdu/kTNVJjA9vjUPhcc46oJuK1SgmUA4IkYuXp\nJZeS3NY/HFwDrC3ekpkonu/tbocGq1vWOJQl7Q5CUD9sui51nr9JSIISrLZ+\nNcWH4dpX2z/B2VRnZbwdglqIS99mn9LPPppfUSLKhx7cxTjPycqEXWs4Aue9\necZp3DfXsGJvKcuSYmU2PRairL1dBKN8uL36wyg6N0GQ8f2FwUfh/DHPKTry\ntPNH9ALCsfuWBe7U6VGl2Pff2CMgMhEr64KML0VHDKemOTRi0ccU0w6G+EFD\nX88f1LKhSA3+qdHhCXIs6wK3Kv++WCv0M4kUXoNZKJzysEhP4fAKhXOFARBe\nqsy7PqNJWkbDZpWHbYMmxeD65jcZ9DngYl8hlQyNuycJBzjreNERkGXZKtbM\n4kTG\r\n=6GFv\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIH1IkxVPGmBUqE6nIjz+5HM73XgDN705+1xs+hMHoYh4AiEAhql6tdLM60bP94X9TIK3+bvwzW6le9Tpx32fyIz2TbY="}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.3_1637816482575_0.6238756223623179"},"_hasShrinkwrap":false},"0.2.4":{"name":"@3d-dice/dice-roller-parser","version":"0.2.4","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.4.1","@types/node":"^16.11.26","jest":"^27.5.1","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.1.3","ts-loader":"^9.2.7","tslint":"^6.1.3","typescript":"^4.6.2","webpack":"^5.70.0","webpack-cli":"^4.9.2"},"gitHead":"215ba9f82228185ac39cab17c0eb3d8f8d483503","_id":"@3d-dice/dice-roller-parser@0.2.4","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-h/AietClYq/fBrNn3yk3ags0zGs895L5ZDAR3AOoqexFqsGM5i0/sL93pV+Tg0hu2mVuVZOKiMo5BxH/TjCwDg==","shasum":"1756baad292a95948060e6ffd7ca1a3c9c4577fe","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.4.tgz","fileCount":10,"unpackedSize":278279,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiIRtNACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmp+Uw/+IQZiXnCCCFHfy79AWEJN93KgorGTZojyvPt6PFYVaRZ0bj4W\r\nSf659LbVstDah9vzmr1m8Kpe3htuwAND3G4hHJbZfjlBi3hqoYcDtvSRsS4g\r\nmR4Heg+y/cJz7Y0JgQvw8Sq9fpBVjSRXjFJ0bNPa2MgsU/rGftdkUX1ojqhH\r\nRt89Q22+fOkQx3/TBFqlQMt/nXYDNoglvEIzImQfQwHqZjDVovf0KuvmruzV\r\n0VgYCL+nLHUzcUVIG3KGOMDdWw5NqaZYNraofeavwMVrQp6fmINMWc5tk9k1\r\n1JCFk6TMpyibKEJvSdefZXKnyaq3RAJrQp0KF5vnx4drFe8T5sUC0qYFkZDW\r\nr4OWQmXvy20u501JIGF2Vcf3ExPva7o1sOB6VkKYH6KP+T3e94SQyILXBsks\r\n4djzusYtB+Ks0374NloBYavWdFdp6Suw43Ztvmtau0+xil2MYqDxGheN7MCs\r\nGIskkcT/08j82I1bwo+4d6x682vkqpj3meASZGyEWJ7InvbSOI8Ut4vlO4m6\r\nBfeDNFVUw1TlvYklqLUoEOo0Y1pzvUaDgL7Gvm1cpDVBrdMvOUPWb4SBDg7P\r\nddIRG9G5UEMDAatg/C5jiQvfFJ+2dSlC01qMv0SxABiNItCvmuHPk7UmULyr\r\n6soaMPU/ddgZYvCFznjcbUanF8m0tXc6KOk=\r\n=dMeb\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCl2JVxCpjMdKaLfCP+1+4vg1AHa7Meeexoc7WKAvbf8AIhANDKFCZU4X7WQcfoV1PHppD6iCNsnBjXB7YM84Q+r6VI"}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.4_1646336845716_0.6676116654221711"},"_hasShrinkwrap":false},"0.2.5":{"name":"@3d-dice/dice-roller-parser","version":"0.2.5","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.4.1","@types/node":"^16.11.26","jest":"^27.5.1","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.1.3","ts-loader":"^9.2.7","tslint":"^6.1.3","typescript":"^4.6.2","webpack":"^5.70.0","webpack-cli":"^4.9.2"},"gitHead":"9da498e514a7798f19b85385bd43d5568962e492","_id":"@3d-dice/dice-roller-parser@0.2.5","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-kUtuAedSKixPqVVhpTJ1NCP2KWOwXEybeKV7X1bjBa97QzqfA2SpqaZUQac8eRzuJosyPLu31+a1EHwMKrPNTw==","shasum":"943f70284259a2e8dd0ae6460745217cf7481065","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.5.tgz","fileCount":10,"unpackedSize":278245,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJiLOPJACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpUkg/+OEy2ly+SHPtRjvj4Cm/7WXHaJuRbN1g6A8dTB7sZJ0MIWRAE\r\n8Cwdk/jdoyY9SuIPhR2QcLBV23KfGj5s+F/r1/o5f67Bl6rcK/o6pJTSKQNd\r\nGHjYPEV7wPd9bIo35l6SahQKKSYg0Qmc3TiP9B/g1fQjCar6V5e5TBBcJlGa\r\nrgmIKczzQxkPKZlUn6lMEyP5H6Do6PZvf005wUj395hAOEaZFZs8afQt7cPM\r\nF44t1EUeQXf8yQUot5WSBGRNmr1evrs5GsukHrjIc9jFZjYj1rfLOR40uP3f\r\nmh2546cvaCPEJK/l8fYMc4RsZnDwkKWTGZSP6KT/Tolu3zCANgf4ENN8TmdS\r\nVtmTgKo6h07UVNWeuJCA74i95DEfOraMvEiYaM5BIYEDIeTXppsLhTQsBODN\r\nqMGVtu8q28c54toCiZ4F1Lp8hGs8g/6K2NFQtlu4L8iXJXqe4EvC3KhAdQyn\r\nLC+lErmACXXsp50Hj1ttX/lb5AYKzKgb+SGS/IMkWdrmB1aJHb+AgZGYhhor\r\nC/dAy0541P7KP0FGfE1NVIyAUzzdS8x56J5EkdzXOkY0XuiPcNv+vb12UXiN\r\nkjSv/BLZhyuSYdMAifFKHNgLfFz+sirfsnQE9xyY28oqq2a3zCBo9NDJWm79\r\nJ7TzkJ5KlQoLulwBWgOqus4SU11I9+KZkdc=\r\n=s0D2\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIHDNEl/08+t6U5TWRYBnf86utw6ZOp0A2vLVI1HIGQo9AiEAo1a8Z+Bqjo4j0M0AwbBl2BAdMWlu8yPFLvDQi/uZkdU="}]},"_npmUser":{"name":"3d-dice","email":"frankieali4@hotmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"frankieali4@hotmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.5_1647109065417_0.6134138487439145"},"_hasShrinkwrap":false},"0.2.6":{"name":"@3d-dice/dice-roller-parser","version":"0.2.6","description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","main":"dist/index.js","module":"dist/index.js","types":"dist/index.d.ts","typings":"dist/index.d.ts","scripts":{"build":"npm run clean && pegjs src/diceroll.pegjs && tslint -c tslint.json --project tsconfig.json && webpack","clean":"rimraf dist/ src/diceroll.js","test":"jest","prepublishOnly":"npm run build","prepare":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"license":"MIT","bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"homepage":"https://github.com/3d-dice/dice-roller-parser#readme","devDependencies":{"@types/jest":"^27.5.1","@types/node":"^16.11.36","jest":"^27.5.1","pegjs":"^0.10.0","rimraf":"^3.0.2","ts-jest":"^27.1.5","ts-loader":"^9.3.0","tslint":"^6.1.3","typescript":"^4.7.2","webpack":"^5.72.1","webpack-cli":"^4.9.2"},"gitHead":"0e7387b8bac107336c08ec14e08e6339c2a31b4f","_id":"@3d-dice/dice-roller-parser@0.2.6","_nodeVersion":"14.15.0","_npmVersion":"6.14.8","dist":{"integrity":"sha512-9dMSX0bqKZ5BQ+HABE4c4ZY1/VPUqtQd+gXKAHPMcFbY3cCMOPy327ZQ/LHdptS7VNZCGPriybIQrg7efYIQEw==","shasum":"bae45daf24390e82eae504b511769d5c0dac0403","tarball":"https://registry.npmjs.org/@3d-dice/dice-roller-parser/-/dice-roller-parser-0.2.6.tgz","fileCount":10,"unpackedSize":278177,"signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIC+tO5ff0RDeXGAuVRbzSHR1KwepqnPnygsQAplRdtuBAiEAoZuENf1cIpMiZ6rjI3vI60B7pKxMp4V7e+z4SAaD3oU="}],"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJij66RACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2Vmp7gg//SwafrhDTOkdEBC0HXPrcqxH9YoWW0m0rWhImYbOXzjU8x4Oe\r\nYhnj/De5NSHzHmcOd1YQFEZC8+cgA8l3PW0hJ2vtrq4PXaleKR1aL3NCHP25\r\noV8KwUQ2W6aTR2oJUFgZEw5+4rJEwnGzay0oSgYV43ovP6TmAlwH+Sd1Y2ib\r\nRCUkmqUlo4+czIZ6ufldapfudh+E5YTFwi2Vz+0kcX/mVqtq5CgVYvpA8VBc\r\n+KxazcDeosYNdPNpCKWT8HNsJpLV5jgpRlH/YnFFmCKaNXSfmcWCJNt5u/V5\r\nGDrmyFKS+9XdTxBe7Rmg4znoLfcebIVF9A8nLietscSY6yOCbOyT9sVu1vvI\r\nfbZNwnC93vZvNsLpxh1gx5sKbqxSwF6h7SmHxyYOa7Sm0dUxe/tdhHhHCMnn\r\n5okDuW2uN4e70yiCrP3TZpINBExegF4pnBq+WfaZsnR6uXFIw4qhUtQm9ggx\r\nHdPjEJuoOMPan84WklOW07WZLcT7rt9Xnq8hzqm/6BlXsl5OyAk7xQtM+lAm\r\nR4/S5AK8g9+ums6RSunnruU21MK4N46y/PNfaHBvhg7R1dtLOpvWxq+o2BKZ\r\nqiWSMBpPi+V90BmUgXIEYBsmFRZHpsTbKkd2zLgXkUbRSC1+t61LuNzFVuqS\r\n1MAJMtbqneHy1uZC4imMJA4j1Cj2685BtHg=\r\n=xcDH\r\n-----END PGP SIGNATURE-----\r\n"},"_npmUser":{"name":"3d-dice","email":"fantastic.3d.dice@gmail.com"},"directories":{},"maintainers":[{"name":"3d-dice","email":"fantastic.3d.dice@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/dice-roller-parser_0.2.6_1653583505472_0.42968877009999673"},"_hasShrinkwrap":false}},"time":{"created":"2021-09-14T16:33:01.622Z","0.1.9":"2021-09-14T16:33:01.843Z","modified":"2022-05-26T16:45:05.710Z","0.2.0":"2021-11-25T04:16:08.887Z","0.2.1":"2021-11-25T04:44:43.733Z","0.2.2":"2021-11-25T04:54:24.532Z","0.2.3":"2021-11-25T05:01:23.019Z","0.2.4":"2022-03-03T19:47:25.839Z","0.2.5":"2022-03-12T18:17:45.586Z","0.2.6":"2022-05-26T16:45:05.643Z"},"maintainers":[{"name":"3d-dice","email":"fantastic.3d.dice@gmail.com"}],"description":"A javascript dice roller that parses roll20 format strings and generates rolled outputs","homepage":"https://github.com/3d-dice/dice-roller-parser#readme","keywords":["dice","roller","roll","roll20","rpg","trpg","tabletop","dnd","d&d","dungeons","dragons","pathfinder"],"repository":{"type":"git","url":"git+https://github.com/3d-dice/dice-roller-parser.git"},"contributors":[{"name":"Frank Ali","email":"frankieali4@gmail.com"}],"author":{"name":"Ben Morton","email":"ben.morton91@gmail.com"},"bugs":{"url":"https://github.com/3d-dice/dice-roller-parser/issues"},"license":"MIT","readme":"# Dice Roller & Parser\n\nThis dice roller is a string parser that returns an object containing the component parts of the dice roll. It supports the full [Roll20 Dice Specification](https://roll20.zendesk.com/hc/en-us/articles/360037773133-Dice-Reference#DiceReference-Roll20DiceSpecification). It uses a [pegjs](https://github.com/pegjs/pegjs) grammar to create a [representation of the dice roll format](#parsed-roll-output). This can then be converted into a simple number value, or to a [complex object](#roll-result-output) used to display the full roll details.\n\n## Credit\nThis is a fork of Ben Morton's [dice_roller](https://github.com/BTMorton/dice_roller) project. It had a few bugs so I'm republishing with fixes and features needed for my projects.\n\n## Quickstart\n\nInstall the library using:\n\n```bash\nnpm install dice-roller-parser\n```\n\nOnce installed, simply load the library, either in the browser:\n\n```html\n<script src=\"node_modules/dice-roller-parser/dist/index.js\"></script>\n```\n\nOr in node:\n\n```javascript\nimport { DiceRoller } from \"dice-roller-parser\";\n```\n\nThen create a new instance of the [`DiceRoller`](#DiceRoller) class, and use it to perform some dice rolls.\n\n```javascript\nconst diceRoller = new DiceRoller();\n\n//\tReturns the total rolled value\nconst roll = diceRoller.rollValue(\"2d20kh1\");\nconsole.log(roll);\n\n//\tReturns an object representing the dice roll, use to display the component parts of the roll\nconst rollObject = diceRoller.roll(\"2d20kh1\");\nconsole.log(rollObject.value);\n```\n\n## Usage\n\nThis library exposes two classes, a [`DiceRoller`](#DiceRoller) and a [`DiscordRollRenderer`](#DiscordRollRenderer).\n\n### `DiceRoller`\n\nThe `DiceRoller` class manages parsing of a dice string and performing rolls based upon the result.\n\n```javascript\n//\tCreates a new instance of the DiceRoller class\nconst roller = new DiceRoller();\n```\n\n#### Constructor options\n\nThe default constructor uses `Math.random` and applies a maximum number of rolls per die of 1000. These can be specified using the following constructor overloads.\n\n##### `DiceRoller(GeneratorFunction)`\n\nYou can specify a function to be used as the random number generator by the dice roller. This function should be of the type `() => number` and return a number between 0 and 1. By default, it uses the built-in `Math.random` method.\n\n```javascript\n//\tDefault constructor using Math.random\nconst roller = new DiceRoller();\n\n//\tUses a custom random generator that always returns 0.5\nconst roller = new DiceRoller(() => 0.5);\n```\n\nThis can be read or modified using the `randFunction` property.\n\n```javascript\nroller.randFunction = () => 0.5;\n```\n\n##### `DiceRoller(GeneratorFunction, MaxRollsPerDie)`\n\nTo prevent attempting to parse very large numbers of die rolls, a maximum number of rolls for a die can be specified. The default value is set to 1000.\n\n```javascript\n//\tUses the default constructor with a limit of 100 rolls per die\nconst roller = new DiceRoller(null, 100);\n\n//\tUses a custom random generator that always returns 0.5, and a limit of 10 rolls per die\nconst roller = new DiceRoller(() => 0.5, 10);\n```\n\nThis can be read or modified using the `maxRollCount` property.\n\n```javascript\nroller.maxRollCount = 75;\n```\n\n#### Class Usage\n\nOnce the `DiceRoller` class has been constructed, there are three options for performing a dice roll:\n\n-   Getting a roll result directly\n-   Generate an object to represent the dice roll\n-   Just parse the input and add your own rolling logic\n\n##### Getting a direct roll result\n\nThe `rollValue` method takes a dice string input, parses it, performs a roll and returns the calculated number value result.\n\n```javascript\n//\tRolls 2 d20 dice and keeps the value of the highest\nconst roll = roller.rollValue(\"2d20kh1\");\n\n//\tPrints out the numeric value result\nconsole.log(roll);\n```\n\n##### Generate an object representing the dice roll\n\nThe `roll` method takes a dice string input, parses it, performs a roll and then returns an object that represents the roll. Using the roll objects, you can build your own roll display functionality, rather than just outputting the final value.\n\n```javascript\n//\tRolls 2 d20 dice and keeps the value of the highest\nconst roll = roller.roll(\"2d20kh1\");\n\n//\tPrint out the full roll breakdown\nprintDiceRoll(roll);\n//\tPrints out the numeric value result\nconsole.log(`Final roll value: ${roll.Value}`);\n```\n\nSee the [roll result output](#roll-result-output) in the [output types](#output-types) section below for more details on the returned object.\n\n##### Just parse the value\n\nThe `parse` method takes a dice string input, parses it and returns a representation of the parsed input. This can either be used to perform a dice roll or re-construct the original input. The `rollParsed` method takes this parsed result as an input, performs the roll and returns the same output as from the [`roll`](#generate-an-object-representing-the-dice-roll) method.\n\n```javascript\n//\tRolls 2 d20 dice and keeps the value of the highest\nconst parsedInput = roller.parse(\"2d20kh1\");\n\n//\tPrint out a re-constructed input string\nprintParsedInput(parsedInput);\n\n//\tRun the roller on the parsed object\nconst roll = roller.rollParsed(parsedInput);\n\n//\tPrint out the full roll breakdown\nprintDiceRoll(roll);\n//\tPrint out the numeric value result\nconsole.log(`Final roll value: ${roll.Value}`);\n```\n\nSee the [parsed roll output](#parsed-roll-output) in the [output types](#output-types) section below for more details on the returned object.\n\n### `DiscordRollRenderer`\n\nThe `DiscordRollRenderer` class is an example renderer class that takes a rolled input represented by a [`RollBase`](#RollBase) object and renders it to a string in a markdown format, compatible with Discord.\n\n```javascript\n//\tCreates a new instance of the DiceRoller class\nconst renderer = new DiscordRollRenderer();\n```\n\n#### Class Usage\n\nThe `DiscordRollRenderer` exposes a single `render` method with a single parameter, the [`RollBase`](#RollBase) object to render, and returns the rendered string.\n\n```javascript\n//\tRolls 2 d20 dice and keeps the value of the highest\nconst roll = roller.rollValue(\"2d20kh1\");\n\n//\tGet the formatted string\nconst render = renderer.render(roll);\nconsole.log(render);\n```\n\n## Development\n\nTo develop this library, simply clone the repository, run an install:\n\n```bash\nnpm install\n```\n\nThen do a build:\n\n```bash\nnpm run build\n```\n\nThis does four things:\n\n```bash\n# Clean any existing builds\nnpm run clean\n\n# Build the dice grammer\nnpx pegjs src/diceroll.pegjs\n\n# Run tslint against the project\ntslint -c tslint.json --project tsconfig.json\n\n# Then run webpack to build and package everything up nicely\nwebpack\n```\n\nTo run the test suite, use:\n\n```bash\nnpm run test\n```\n\nThat's all there is to it!\n\n## Output Types\n\nThe following object types are output from the [`DiceRoller`](#DiceRoller) class, and are available as interfaces for typescript users.\n\n### Roll Result Output\n\nThe object returned by a roll result is made up of the following types.\n\n#### `RollBase`\n\nThe base class for all die rolls, extended based upon the type property.\n\n| Property | Type                    | Description                                                         |\n| -------- | ----------------------- | ------------------------------------------------------------------- |\n| success  | `boolean`               | Was the roll a success, for target number rolls. Example: `3d6 > 3` |\n| type     | [`RollType`](#RollType) | The type of roll that this object represents.                       |\n| valid    | `boolean`               | Is the roll still valid, and included in calculations.              |\n| value    | `number`                | The rolled or calculated value of this roll.                        |\n| label    | `string`                | The display label for this roll. This property is optional.         |\n| order    | `number`                | A property used to maintain ordering of dice rolls within groups.   |\n\n#### `RollType`\n\nAn enum of the valid types of roll. The possible values are:\n\n-   `\"number\"`\n-   [`\"diceexpressionroll\"`](#DiceExpressionRoll)\n-   [`\"expressionroll\"`](#ExpressionRoll)\n-   [`\"mathfunction\"`](#MathFunctionRoll)\n-   [`\"grouproll\"`](#GroupRoll)\n-   `\"fate\"`\n-   [`\"die\"`](#DiceRollResult)\n-   [`\"roll\"`](#DieRoll)\n-   [`\"fateroll\"`](#FateDieRoll)\n\n#### `GroupedRoll`\n\nAn intermediate interface extended for groups of dice. This interface extends [`RollBase`](#RollBase).\n\n| Property | Type                               | Description                               |\n| -------- | ---------------------------------- | ----------------------------------------- |\n| dice     | `Array<`[`RollBase`](#RollBase)`>` | The rolls included as part of this group. |\n\n#### `DiceExpressionRoll`\n\nA representation of a dice expression. This interface extends [`GroupedRoll`](#GroupedRoll).\n\n**Example**\n\n> `2d20 + 6d6`\n\n| Property | Type                                                           | Description                                   |\n| -------- | -------------------------------------------------------------- | --------------------------------------------- |\n| type     | `\"diceexpressionroll\"`                                         | The type of roll that this object represents. |\n| ops      | `Array<`[`DiceGroupMathOperation`](#DiceGroupMathOperation)`>` | The operations to perform on the rolls.       |\n\n#### `ExpressionRoll`\n\nA representation of a mathematic expression. This interface extends [`GroupedRoll`](#GroupedRoll).\n\n**Example**\n\n> `20 * 17`\n\n| Property | Type                                         | Description                                   |\n| -------- | -------------------------------------------- | --------------------------------------------- |\n| type     | `\"expressionroll\"`                           | The type of roll that this object represents. |\n| ops      | `Array<`[`MathOperation`](#MathOperation)`>` | The operations to perform on the rolls.       |\n\n#### `MathFunctionRoll`\n\nA representation of a mathematic function. This interface extends [`RollBase`](#RollBase).\n\n**Example**\n\n> `floor(20 / 17)`\n\n| Property | Type                            | Description                                       |\n| -------- | ------------------------------- | ------------------------------------------------- |\n| type     | `\"expressionfunc\"`              | The type of roll that this object represents.     |\n| op       | [`MathFunction`](#MathFunction) | The operations to perform on the rolls.           |\n| expr     | [`RollBase`](#RollBase)         | The expression that the function is applied upon. |\n\n#### `GroupRoll`\n\nA representation of a group of rolls\n\n**Example**\n\n> {4d6,3d6}. This interface extends [`GroupedRoll`](#GroupedRoll).\n\n| Property | Type          | Description                                   |\n| -------- | ------------- | --------------------------------------------- |\n| type     | `\"grouproll\"` | The type of roll that this object represents. |\n\n#### `DiceRollResult`\n\nThe rolled result of a group of dice. This interface extends [`RollBase`](#RollBase).\n\n**Example**\n\n> `6d20`\n\n| Property | Type                            | Description                                   |\n| -------- | ------------------------------- | --------------------------------------------- |\n| die      | [`RollBase`](#RollBase)         | The die this result represents.               |\n| type     | `\"die\"`                         | The type of roll that this object represents. |\n| rolls    | [`DieRollBase`](#DieRollBase)[] | Each roll of the die.                         |\n| count    | [`RollBase`](#RollBase)         | The number of rolls of the die.               |\n| matched  | `boolean`                       | Whether this is a match result.               |\n\n#### `DieRollBase`\n\nAn intermediate interface extended for individual die rolls (see below). This interface extends [`RollBase`](#RollBase).\n\n| Property | Type      | Description                   |\n| -------- | --------- | ----------------------------- |\n| roll     | `number`  | The rolled result of the die. |\n| matched  | `boolean` | Whether this roll is a match. |\n\n#### `DieRoll`\n\nA roll on a regular die. This interface extends [`DieRollBase`](#DieRollBase).\n\n**Example**\n\n> `d20`\n\n| Property | Type                            | Description                                                    |\n| -------- | ------------------------------- | -------------------------------------------------------------- |\n| die      | `number`                        | The die number to be rolled.                                   |\n| type     | `\"roll\"`                        | The type of roll that this object represents.                  |\n| critical | [`CriticalType`](#CriticalType) | If this role is a critical success or failure (for rendering). |\n\n#### `FateDieRoll`\n\nA roll on a fate die. This interface extends [`DieRollBase`](#DieRollBase).\n\n**Example**\n\n> `dF`\n\n| Property | Type         | Description                                   |\n| -------- | ------------ | --------------------------------------------- |\n| type     | `\"fateroll\"` | The type of roll that this object represents. |\n\n### Parsed Roll Output\n\nThe following interfaces are exposed by the library as a reresentation of the parsed input string. The response from the `parse` method is a `RootType` object and could be any of the interfaces that extend it.\n\n#### `ParsedObjectType`\n\nAn enum of the valid types of roll. The possible values are:\n\n-   [`\"number\"`](#NumberType)\n-   [`\"inline\"`](#InlineExpression)\n-   [`\"success\"`](#SuccessFailureCritModType)\n-   [`\"failure\"`](#SuccessFailureCritModType)\n-   [`\"crit\"`](#SuccessFailureCritModType)\n-   [`\"critfail\"`](#SuccessFailureCritModType)\n-   [`\"match\"`](#MatchModType)\n-   [`\"keep\"`](#KeepDropModType)\n-   [`\"drop\"`](#KeepDropModType)\n-   [`\"group\"`](#GroupedRoll)\n-   [`\"diceExpression\"`](#RollExpressionType)\n-   [`\"sort\"`](#SortRollType)\n-   [`\"explode\"`](#ReRollMod)\n-   [`\"compound\"`](#ReRollMod)\n-   [`\"penetrate\"`](#ReRollMod)\n-   [`\"reroll\"`](#ReRollMod)\n-   [`\"rerollOnce\"`](#ReRollMod)\n-   [`\"target\"`](#TargetMod)\n-   [`\"die\"`](#DiceRoll)\n-   [`\"fate\"`](#FateExpr)\n-   [`\"expression\"`](#MathExpression)\n-   [`\"math\"`](#MathType)\n-   [`\"mathfunction\"`](#MathFunctionExpression)\n\n#### `ParsedType`\n\nThis is the base interface for all parsed types.\n\n| Property | Type     | Description                                     |\n| -------- | -------- | ----------------------------------------------- |\n| type     | `string` | The type of parsed item this object represents. |\n\n#### `RootType`\n\nThis is the base interface for a subset of parsed types, only those that can be the root type. This object extends the [`ParsedType`](#ParsedType) interface.\n\n| Property | Type      | Description                                                       |\n| -------- | --------- | ----------------------------------------------------------------- |\n| label?   | `string`  | The text label attached to this roll. This property is optional.  |\n| root     | `boolean` | A boolean flag to indicate if this is the root of the parse tree. |\n\n#### `NumberType`\n\nThis object represents a single number in the input. This object extends the [`RootType`](#RootType) interface.\n\n| Property | Type       | Description                                     |\n| -------- | ---------- | ----------------------------------------------- |\n| type     | `\"number\"` | The type of parsed item this object represents. |\n| value    | `number`   | The value of the number.                        |\n\n#### `InlineExpression`\n\nThis object represents an inline dice expression within a string, wrapped in double square brackets. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `I want to roll [[2d20]] dice`\n\n| Property | Type                        | Description                                          |\n| -------- | --------------------------- | ---------------------------------------------------- |\n| type     | `\"inline\"`                  | The type of parsed item this object represents.      |\n| expr     | [`Expression`](#Expression) | The expression that was parsed as the inline string. |\n\n#### `AnyRoll`\n\nA combined type representing any valid roll. This is a combination of the following types:\n\n-   [`GroupedRoll`](#GroupedRoll)\n-   [`FullRoll`](#FullRoll)\n-   [`NumberType`](#NumberType)\n\n#### `ModGroupedRoll`\n\nThis object represents a grouped roll with an optional modifier. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `{4d6+3d8}kh1`\n\n| Property | Type                                                                                                 | Description                                      |\n| -------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------ |\n| mods     | `Array<`[`KeepDropModType`](#KeepDropModType)`,`[`SuccessFailureModType`](#SuccessFailureModType)`>` | The modifiers to be applied to the grouped roll. |\n\n#### `SuccessFailureCritModType`\n\nAn object representing a success test modifier. This object extends the [`ParsedType`](#ParsedType) interface.\nA `\"success\"` or `\"failure\"` modifier converts the result into a success type result which returns the number of rolls that meet the target.\nA `\"crit\"` or `\"critfail\"` modifier tests the roll for whether or not the roll should be displayed as a critical success or critical failure.\n\n**Example**\n\n> Success: `3d6>3`\n> Failure: `3d6f<3`\n\n| Property | Type                                       | Description                                       |\n| -------- | ------------------------------------------ | ------------------------------------------------- |\n| type     | `\"success\", \"failure\", \"crit\", \"critfail\"` | The type of parsed item this object represents.   |\n| mod      | [`CompareOperation`](#CompareOperation)    | The check type to use for the condition.          |\n| expr     | [`RollExpression`](#RollExpression)        | An expression representing the success condition. |\n\n#### `SuccessFailureModType`\n\nEquivalent to the [`SuccessFailureCritModType`](#SuccessFailureCritModType) but only supporting \"success\" and \"failure\" modifiers. This object extends the [`SuccessFailureCritModType`](#SuccessFailureCritModType) interface.\n\n**Example**\n\n> Success: `3d6>3`\n> Failure: `3d6f<3`\n\n| Property | Type                                    | Description                                       |\n| -------- | --------------------------------------- | ------------------------------------------------- |\n| type     | `\"success\", \"failure\"`                  | The type of parsed item this object represents.   |\n| mod      | [`CompareOperation`](#CompareOperation) | The check type to use for the condition.          |\n| expr     | [`RollExpression`](#RollExpression)     | An expression representing the success condition. |\n\n#### `MatchModType`\n\nAn object representing a match type modifier, used to modify the display of dice output in roll20. This object extends the [`ParsedType`](#ParsedType) interface.\n\n**Example**\n\n> `2d6m`\n\nWhen used with the `mt` extension, will return the number of matches found.\n\n**Example**\n\n> `20d6mt`\n\nAdditional arguments can be specified that increase the required number of matches or to add a constraint to matches.\n\n**Example**\n\n> `20d6mt3 counts matches of 3 items`\n\n**Example**\n\n> `20d6m>3 Only counts matches where the rolled value is > 3`\n\n| Property | Type                                    | Description                                                                                            |\n| -------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------ |\n| type     | `\"match\"`                               | The type of parsed item this object represents.                                                        |\n| min      | [`NumberType`](#NumberType)             | The minimum number of matches to accept. This property defaults to 2 as a [`NumberType`](#NumberType). |\n| count    | `boolean`                               | Whether or not to count the matches.                                                                   |\n| mod?     | [`CompareOperation`](#CompareOperation) | The check type to use for the match condition, if specified. This field is optional.                   |\n| expr?    | [`RollExpression`](#RollExpression)     | An expression representing the match condition, if specified. This field is optional.                  |\n\n#### `KeepDropModType`\n\nAn object representing a keep or drop modifier, specifying a number of dice rolls to keep or drop, either the highest or lowest rolls. This object extends the [`ParsedType`](#ParsedType) interface.\n\n**Example**\n\n> Keep: `2d20kh1`\n> Drop: `2d20dl1`\n\n| Property | Type                                | Description                                                                                                                               |\n| -------- | ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |\n| type     | `\"keep\", \"drop\"`                    | The type of parsed item this object represents.                                                                                           |\n| highlow  | [`HighLowType`](#HighLowType)       | Whether to keep/drop the highest or lowest roll.                                                                                          |\n| expr     | [`RollExpression`](#RollExpression) | An expression representing the number of rolls to keep/drop. This property defaults to 1 as a [`NumberType`](#NumberType). Example: `2d6` |\n\n#### `GroupedRoll`\n\nThis object represents a group of rolls combined, with optional modifiers. This object extends the [`ModGroupedRoll`](#ModGroupedRoll) interface.\n\n**Example**\n\n> `{2d6,3d6}`\n\n| Property | Type                                           | Description                                     |\n| -------- | ---------------------------------------------- | ----------------------------------------------- |\n| type     | `\"group\"`                                      | The type of parsed item this object represents. |\n| rolls    | `Array<`[`RollExpression`](#RollExpression)`>` | The group of rolls included in this group.      |\n\n#### `RollExpressionType`\n\nAn object representing a roll expression including complex rolls and groups, only allows addition operations. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `{2d6,3d6}kh1 + {3d6 + 2d6}kh2`\n\n| Property | Type                                                                                                                                | Description                                                |\n| -------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |\n| head     | [`RollOrExpression`](#RollOrExpression)                                                                                             | The initial roll or expression for the roll expression.    |\n| type     | `\"diceExpression\"`                                                                                                                  | The type of parsed item this object represents.            |\n| ops      | `Array<`[`MathType`](#MathType)`<`[`RollOrExpression`](#RollOrExpression)`,`[`DiceGroupMathOperation`](#DiceGroupMathOperation)`>>` | The operations to apply to the initial roll or expression. |\n\n#### `RollExpression`\n\nA helper type combination of a complex roll expression, a roll, or a math expression. Represents the following types:\n\n-   [`RollExpressionType`](#RollExpressionType)\n-   [`RollOrExpression`](#RollOrExpression)\n\n#### `RollOrExpression`\n\nA helper type combination of a roll, or a math expression. Represents the following types:\n\n-   [`FullRoll`](#FullRoll)\n-   [`Expression`](#Expression)\n\n#### `FullRoll`\n\nAn object representing a roll including the dice roll, and any modifiers. This object extends the [`DiceRoll`](#DiceRoll) interface.\n\n**Example**\n\n> `2d6kh1`\n\n| Property | Type                                                                         | Description                                                             |\n| -------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------- |\n| mods?    | `Array<`[`ReRollMod`](#ReRollMod)`,`[`KeepDropModType`](#KeepDropModType)`>` | Any modifiers attached to the roll. This property is optional.          |\n| targets? | `Array<`[`SuccessFailureCritModType`](#SuccessFailureCritModType)`>`         | Any success or failure targets for the roll. This property is optional. |\n| match?   | [`MatchModTyp`](#MatchModTyp)                                                | Any match modifiers for the roll. This property is optional.            |\n| sort?    | [`SortRollType`](#SortRollType)                                              | Any sort operations to apply to the roll. This property is optional.    |\n\n#### `SortRollType`\n\nA sort operation to apply to a roll. This object extends the [`ParsedType`](#ParsedType) interface.\n\n**Example**\n\n> `10d6sa`\n\n| Property | Type      | Description                                     |\n| -------- | --------- | ----------------------------------------------- |\n| type     | `\"sort\"`  | The type of parsed item this object represents. |\n| asc      | `boolean` | Whether to sort ascending or descending.        |\n\n#### `ReRollMod`\n\nAn object representing a re-roll operation to apply to a roll. Can be one of the following types:\n\n-   `\"explode\"`: re-rolls any dice that meet the target, continuing if the new roll matches\n-   `\"compound\"`: re-rolls any dice that meet the target, continuing if the new roll matches and adding the results into a single roll\n-   `\"penetrate\"`: re-rolls any dice that meet the target subtracting 1 from the new value, continuing if the new roll matches\n-   `\"reroll\"`: re-rolls a die as long as it meets the target, keeping the final roll\n-   `\"rerollOnce\"`: re-rolls a die once if it meets the target, keeping the new roll\n\n**Example**\n\n> `2d6!`\n\n| Property | Type                                                         | Description                                            |\n| -------- | ------------------------------------------------------------ | ------------------------------------------------------ |\n| type     | `\"explode\", \"compound\", \"penetrate\", \"reroll\", \"rerollOnce\"` | The type of parsed item this object represents.        |\n| target   | [`TargetMod`](#TargetMod)                                    | The target modifier to compare the roll value against. |\n\n#### `TargetMod`\n\nAn object represting a target modifier to apply to a roll. This object extends the [`ParsedType`](#ParsedType) interface.\n\n| Property | Type                                    | Description                                            |\n| -------- | --------------------------------------- | ------------------------------------------------------ |\n| type     | `\"target\"`                              | The type of parsed item this object represents.        |\n| mod      | [`CompareOperation`](#CompareOperation) | The check type to use for the condition.               |\n| value    | [`RollExpr`](#RollExpr)                 | An expression representing the target condition value. |\n\n#### `DiceRoll`\n\nThe representation of a die roll. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `2d6`\n\n| Property | Type                                              | Description                                                                              |\n| -------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------- |\n| die      | [`RollExpr`](#RollExpr)`,`[`FateExpr`](#FateExpr) | The die value to roll against, can be a fate die, a number or a complex roll expression. |\n| count    | [`RollExpr`](#RollExpr)                           | The number of time to roll this die.                                                     |\n| type     | `\"die\"`                                           | The type of parsed item this object represents.                                          |\n\n#### `FateExpr`\n\nThe representation of a fate die roll. This object extends the [`ParsedType`](#ParsedType) interface.\n\n**Example**\n\n> `2dF`\n\n| Property | Type     | Description                                     |\n| -------- | -------- | ----------------------------------------------- |\n| type     | `\"fate\"` | The type of parsed item this object represents. |\n\n#### `RollExpr`\n\nA helper type combination of a number or value that is not an expression. Represents the following types:\n\n-   [`MathExpression`](#MathExpression)\n-   [`NumberType`](#NumberType)\n\n#### `Expression`\n\nA helper type combination of expression types. Represents the following types:\n\n-   [`InlineExpression`](#InlineExpression)\n-   [`MathExpression`](#MathExpression)\n\n#### `MathExpression`\n\nA math type expression between two or more dice rolls. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `2d6 + 3d6 * 4d6`\n\n| Property | Type                                                        | Description                                     |\n| -------- | ----------------------------------------------------------- | ----------------------------------------------- |\n| head     | [`AnyRoll`](#AnyRoll)                                       | The initial roll to perform operations against. |\n| type     | `\"expression\"`                                              | The type of parsed item this object represents. |\n| ops      | `Array<`[`MathType`](#MathType)`<`[`AnyRoll`](#AnyRoll)`>>` | The operations to apply to the initial roll.    |\n\n#### `MathType`\n\nAn object representating an roll math operation to be applied and the value to apply it to. This object extends the [`ParsedType`](#ParsedType) interface.\nThe interface for this object takes a templated type `TailType` which specifies the type of the second value used in the operation.\nThere is a second templated type `OpValues` which specifies the type of operations that can be used. This defaults to `Array<`[`MathOperation`](#MathOperation)>`.\n\n**Example**\n\n> `+ 3d6 (as part of 2d6 + 3d6)`\n\n| Property | Type       | Description                                     |\n| -------- | ---------- | ----------------------------------------------- |\n| type     | `\"math\"`   | The type of parsed item this object represents. |\n| op       | `OpValues` | The math operation to perform.                  |\n| tail     | `TailType` | The second value to use in the operation.       |\n\n#### `MathFunctionExpression`\n\nAn object representing a math function to be applied and the expression to apply it to. This object extends the [`RootType`](#RootType) interface.\n\n**Example**\n\n> `floor(3d6 / 2d4)`\n\n| Property | Type                            | Description                                     |\n| -------- | ------------------------------- | ----------------------------------------------- |\n| type     | `\"mathfunction\"`                | The type of parsed item this object represents. |\n| op       | [`MathFunction`](#MathFunction) | The function to be applied.                     |\n| expr     | [`AnyRoll`](#AnyRoll)           | The expression to apply the function on.        |\n\n### Helper Types\n\nThe following are support types used by the above interfaces.\n\n#### `DiceGroupMathOperation`\n\nA helper type representing the valid operations for a math operation on a group of dice.\n\n> `\"+\" | \"-\"`\n\n#### `MathOperation`\n\nA helper type representing the valid operations for a math operation.\n\n> `\"+\" | \"-\" | \"*\" | \"/\" | \"%\" | \"**\"`\n\n#### `MathFunction`\n\nA helper type representing the valid operations for a math operation.\n\n> `\"floor\" | \"ceil\" | \"round\" | \"abs\"`\n\n#### `CriticalType`\n\nA helper type used when marking a roll as a critical success or failure.\n\n> `\"success\" | \"failure\" | null`\n\n#### `CompareOperation`\n\nA helper type for the available operations for a comparison point.\n\n> `\">\" | \"<\" | \"=\"`\n\n#### `HighLowType`\n\nA helper type used to determine which rolls to keep or drop.\n\n> `\"h\" | \"l\" | null`\n","readmeFilename":"README.md"}