{"_id":"class-plus","_rev":"2-d24706fac92dd291c8c7dfaec6bff4f3","name":"class-plus","dist-tags":{"latest":"2.0.0"},"versions":{"1.0.0":{"name":"class-plus","version":"1.0.0","description":"A simple module for building and extending classes, with mixins and more.","author":{"name":"Joseph Huckaby","email":"jhuckaby@gmail.com"},"homepage":"https://github.com/jhuckaby/class-plus","license":"MIT","main":"class.js","scripts":{"test":"pixl-unit test.js"},"repository":{"type":"git","url":"git+https://github.com/jhuckaby/class-plus.git"},"bugs":{"url":"https://github.com/jhuckaby/class-plus/issues"},"keywords":["oop","class","mixins","async"],"dependencies":{},"devDependencies":{"pixl-unit":"^1.0.0"},"gitHead":"f9f5f98613e01be36906de5d4dbb0ae5e0c15512","_id":"class-plus@1.0.0","_npmVersion":"6.4.1","_nodeVersion":"10.14.1","_npmUser":{"name":"jhuckaby","email":"jhuckaby@gmail.com"},"dist":{"integrity":"sha512-k1a+aPxk1OfVs/+WOcV0LkrcCb5hsA6EKPQTEuLch7jQBLNavDt4tSEZyEYnBbYVkoBOFxdzdZ1aVvbv5VDIKA==","shasum":"406bd042cc3d6b5d176660805e745dab616c9472","tarball":"https://registry.npmjs.org/class-plus/-/class-plus-1.0.0.tgz","fileCount":4,"unpackedSize":24634,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJcy6dECRA9TVsSAnZWagAA7PgP/0ogxHJu4W4uE6cY69aP\ncF3cF3MWYaUvCGI1x4AryatnCfnMwZQaxxUtAegP9pDIcNGxNviEWkIWZrpJ\n+lpdhgHHEo6u1gujyyYFAyZWlP4OSXOpIpnnSzCS44vFYvOHg5M+XoTtnpO/\nk9j4qUmL2uUYYBEUkm3vdEy7FGm3Q9DGArMnUnU6wshyfB6SOMDPCTlMzznr\nhodwMn9znL4JTQi1Z1+eLLBhAxx/Nk/wUcmnkjmrmYi+g4o5AItc9xo1dbWQ\ntPRA4/SFygQgZTy+93dJGgGFQUL+lM3rJ2IE9OzxA3JyMkbgKfZYjVNIdUMm\nLenXOd59IdWyCX8voEgUVUbhE+druu+LSjQ/NIzay5WFCV5dJBHJgwIJhmS9\n7HiOBG6nPjGOn4sM+NVoD08OBDscESk7l+idACf91yNogyU2nQcRwKPlLrDy\n0TmtEdfCdWun4ZBnTOosA6C5TcVMoGKOm13lE9Nva/tDdesHOQqVLNRN+5Bl\nvo3vs5tgs56nsGGXwNRHNPZ7icRwAeHRkgsSBtullKg5Ay/IS1TF345T0jQf\n7Girmte7TcIWS0ux1eb2uAwtzz8kbOlflzduezPvu4MBREjB/IiMz9o7kG+a\nvGKOnChUbDqVCQ5q3Vqwvq6t66MSR+N/6jOxIugOJgu8hDUutjd86kz2vrhI\neo0a\r\n=YwyQ\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCM6Pm6vF1AjP5jIhDwJDKqEfyJNR58S96G50rdsXQ8SwIgT8YQFZiRTLkkwjQL79WFDqsmsTw4nEBSBHS1PBMvzgg="}]},"maintainers":[{"name":"jhuckaby","email":"jhuckaby@gmail.com"}],"directories":{},"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/class-plus_1.0.0_1556850500134_0.5558300078632223"},"_hasShrinkwrap":false},"2.0.0":{"name":"class-plus","version":"2.0.0","description":"A simple module for building and extending classes, with mixins and more.","author":{"name":"Joseph Huckaby","email":"jhuckaby@gmail.com"},"homepage":"https://github.com/jhuckaby/class-plus","license":"MIT","main":"class.js","scripts":{"test":"pixl-unit test.js"},"repository":{"type":"git","url":"git+https://github.com/jhuckaby/class-plus.git"},"bugs":{"url":"https://github.com/jhuckaby/class-plus/issues"},"keywords":["oop","class","mixins","async","await"],"dependencies":{},"devDependencies":{"pixl-unit":"^1.0.0"},"gitHead":"f4f46bf4e630485c7833353117bece3c7d496c0a","_id":"class-plus@2.0.0","_nodeVersion":"16.12.0","_npmVersion":"8.1.0","dist":{"integrity":"sha512-Oyh5EDFkeU6NQZcE5zSbqw/EsXqCmmC/W42BxxcNFRZB0sZ7UZAcDUP77yT8CDuP3f43DofD91HYbDjWvApoaA==","shasum":"d9d0bc75ebe812a49baaba85ac49552817306bb7","tarball":"https://registry.npmjs.org/class-plus/-/class-plus-2.0.0.tgz","fileCount":4,"unpackedSize":30216,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.13\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJh+Y/UCRA9TVsSAnZWagAANwIP/jkcyoAaM1D9ww5qywkx\n3vmfPdHx1W9dWpcnn+2KD2elBBCWB8NuA6Gqr63p4npfEoY7nvPVl5eBdA92\natqPEMGdMf9TKIZK9BSvkrcZmpj2NHX4coEEb3NhrBtDYb3rtm7S5YNkwzyi\n9wVS3TPy6EBAdhmVWoD9PyyLRvGnHW9gG9uggQS1xF35nSrnLLUjcE1pFTVk\nnHbVd8amEzepRP+UR1iItUYo64iepeRcm1hfSshiLw2Vdw4GHKEycty3jG+A\nns4gZkdenOgi0M3hADQnCYs4pJjS7lTdJR8A5+PDidt3DoDgPbfr8yA/tJwZ\n351Bg4LSfXv9R6IkuYX01yPrPh4odk7OURQpRp8aoDCbHwkRBNmjDQ0P2GHK\nd7v23DJawGK/kgSPdO+8BkWaX3cgFVsdQe8w6RXDtY3qnYHXXmETTjVYwhKA\n20G1DK+Mpe+rdMUDjMZlrW/eYTnjZLw6rw/UoiEa1n88owYDN5lwIXNPVucF\nEObAS0kAo9OmJ5vcauDe+Q9E+J4ramZOz/zcoZP+DM/fZunkVXlWnY6AHuyX\nb/SOoRcrI37OlrNWLv42EELL/YClUALbMfnxva0ysl6xMwZJ1vMe9IDBIBgA\ns7L5zAUcZ4ZvdZcJh+rAS4SL+lB6LAEnDE4OSFptFyXt+yXR6Jrkf7zzdBf7\na1gB\r\n=1TGa\r\n-----END PGP SIGNATURE-----\r\n","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDrrnZyiUMC/5sZZE3cLHsgB1GPrbb2Ft2pBEUUgpgDOQIhAOB//Gz/R8J/YU/JYqlI14LliRfNTdj+VmGvqbwazNCB"}]},"_npmUser":{"name":"jhuckaby","email":"jhuckaby@gmail.com"},"directories":{},"maintainers":[{"name":"jhuckaby","email":"jhuckaby@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages","tmp":"tmp/class-plus_2.0.0_1643745236483_0.804313141739661"},"_hasShrinkwrap":false}},"time":{"created":"2019-05-03T02:28:20.133Z","1.0.0":"2019-05-03T02:28:20.419Z","modified":"2022-04-12T06:33:57.631Z","2.0.0":"2022-02-01T19:53:56.590Z"},"maintainers":[{"name":"jhuckaby","email":"jhuckaby@gmail.com"}],"description":"A simple module for building and extending classes, with mixins and more.","homepage":"https://github.com/jhuckaby/class-plus","keywords":["oop","class","mixins","async","await"],"repository":{"type":"git","url":"git+https://github.com/jhuckaby/class-plus.git"},"author":{"name":"Joseph Huckaby","email":"jhuckaby@gmail.com"},"bugs":{"url":"https://github.com/jhuckaby/class-plus/issues"},"license":"MIT","readme":"# Overview\n\n`class-plus` is a simple class builder utility, which adds support for specifying class member variables as well as mix-ins.  It does this by providing a custom API that augments an ES2015 class with custom features.\n\n## Why\n\nNative JavaScript classes (introduced in ECMAScript 2015) are a welcome addition to the language, but two things bother me about them:\n\n1. You cannot declare properties inside the class (you have to do it in the constructor, which I do not like).\n\t- Yes, there is a [TC39 proposal](https://github.com/tc39/proposal-class-fields) for this, but it's not yet available to normal users.\n2. Classes can only inherit from one single parent class.\n\t- I guess mix-ins are [technically possible](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Mix-ins), but the syntax is confusing in my opinion.\n\nI wrote the class-plus module to provide these features to ES2015 classes using a simple API, while offering some additional niceties.  The full set of features are:\n\n- Provide an easy API to generate classes with additions.\n- Support for adding properties right above the class definition (as close to inside it as we can get).\n- Support for multiple mix-ins, will merge both properties and methods from multiple classes.\n- Support for adding static properties.\n- Optional easy way to mix-in the Node.js [EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter) class.\n- Optional hook system (async event emitters).\n- Optional automatic conversion of callback methods to async ones.\n- No dependencies\n\n# Usage\n\nUse [npm](https://www.npmjs.com/) to install the module:\n\n```\nnpm install class-plus\n```\n\nThen use `require()` to load it in your code:\n\n```javascript\nconst Class = require('class-plus');\n```\n\nThen call `Class()` to create classes.  The function takes two arguments: an object with properties for the class, and the class definition itself (in native ES2015 format).  Example:\n\n```javascript\nconst Animal = Class({\n\t// class member variables\n\tnickname: '',\n\tcolor: ''\n},\nclass Animal {\n\t// class methods\n\tconstructor(new_name, new_color) {\n\t\tthis.nickname = new_name;\n\t\tthis.color = new_color;\n\t}\n\t\n\tgetInfo() {\n\t\treturn(\"Nickname: \" + this.nickname + \"\\nColor: \" + this.color);\n\t}\n});\n```\n\nThis defines a class called `Animal`, with two member variables, `nickname` and `color`, a constructor and a `getInfo()` method which returns the nickname and color.  Usage of this class is exactly what you would expect:\n\n```javascript\nvar dog = new Animal('Spot', 'Green');\nconsole.log( dog.getInfo() );\n```\n\nOf course, you can also access the class member variables, as all members are public.\n\n```javascript\ndog.nickname = 'Skippy';\ndog.color = 'Blue';\nconsole.log( dog.getInfo() );\n```\n\n## Creating Subclasses\n\nTo create a subclass that inherits from a base class, use the built-in `extends` keyword:\n\n```javascript\nconst Bear = Class({\n\t// define a new member variable\n\twants: 'Honey'\n},\nclass Bear extends Animal {\n\t// and a new method\n\troar() {\n\t\tconsole.log(\"Roar!  Give me \" + this.wants + \"!\");\n\t}\n});\n```\n\nThis defines a `Bear` class which inherits from the base `Animal` class, including its constructor.  What we did is extend the base class by introducing a new member variable `wants`, and a new method `roar()`.  Everything else from the base class will be present in subclass instances.\n\n```javascript\nvar grizzly = new Bear('Fred', 'Brown');\nconsole.log( grizzly.getInfo() );\n\ngrizzly.wants = 'blood';\ngrizzly.roar();\n```\n\n## Calling Superclass methods\n\nYou can also explicitly invoke a superclass method using the built-in `super` keyword:\n\n```javascript\nconst Bear = Class({\n\t// define a new member variable\n\twants: 'Honey'\n},\nclass Bear extends Animal {\n\t// and a new method\n\troar() {\n\t\tconsole.log(\"Roar!  Give me \" + this.wants + \"!\");\n\t}\n\t\n\t// override base class method\n\tgetInfo() {\n\t\t// first, get info from base class\n\t\tvar info = super.getInfo();\n\t\t\n\t\t// append bear info and return combined info\n\t\tinfo += \"\\nWants: \" + this.wants;\n\t\treturn info;\n\t}\n});\n```\n\nSo here we are overriding the base class `getInfo()` method, but the first thing we do is call the superclass method of the same name.  This is done using the `super` keyword, which points to the parent class.\n\n## Static Members\n\nWhile the native built-in class system supports [static methods](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Static_methods) it doesn't support non-function static *members*.\n\nUsing class-plus you can define static class members (variables or methods) by using the `__static` property.  These members do not become part of class instances, but instead live inside the class reference object, and must be accessed that way too.  Example class definition:\n\n```javascript\nconst Beer = Class({\n\t// static members\n\t__static: {\n\t\ttypes: ['Lager', 'Ale', 'Stout', 'Barleywine']\n\t},\n\t\n\t// class member variables\n\tname: '',\n\ttype: ''\n}, \nclass Beer {\n\t// standard class syntax for methods\n\t\n\t// class constructor\n\tconstructor(new_name, new_type) {\n\t\tthis.name = new_name;\n\t\t\n\t\tif (Beer.types.indexOf(new_type) == -1) throw(\"Type not known: \" + new_type);\n\t\tthis.type = new_type;\n\t}\n\t\n\tgetInfo() {\n\t\treturn(\"Name: \" + this.name + \"\\nType: \" + this.type);\n\t}\n});\n```\n\nHere we define a `Beer` class which has a static member defined in the `__static` property.  Anything placed there will *not* be propagated to class instances, and must be accessed using the class reference variable instead (e.g. `Beer` in the above example).  As you can see in the constructor, we are checking the new type against the `types` array which is declared static, so we are getting to the list by using the syntax: `Beer.types` rather than `this.types`.\n\nIf you were to change `Beer.types` later on, then *all* classes would see the changes instantly.  The content is effectively shared.\n\n## Mix-ins\n\nWhile achieving mix-ins (essentially multiple inheritance) is technically [possible](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Mix-ins) using ES2015 classes, the syntax leaves much to be desired.\n\nUsing class-plus you can simply merge in one or more \"mix-in\" classes using the `__mixins` property.  This will import all the variables, methods and static members from the specified classes, excluding constructors.  Example:\n\n```javascript\nconst Liquid = Class({ flavor: \"sweet\" }, class Liquid {});\nconst Glass = Class({ size: 8 }, class Glass {});\n\nconst Soda = Class({\n\t__mixins: [ Liquid, Glass ]\n},\nclass Soda {\n\tdrink() {\n\t\tconsole.log(\"Yum, \" + this.size + \" oz of \" + this.flavor + \" drink!\");\n\t}\n});\n```\n\nIn the above example we are importing all the variables and methods of the `Liquid` and `Glass` classes into our `Soda` class.  Then, they are accessible using the normal `this` keyword, as if they were defined in the class.\n\nI often use mix-ins to spread my larger classes across multiple source files, like this:\n\n```js\nconst Soda = Class({\n\t__mixins: [ require('./liquid.js'), require('./glass.js') ]\n},\n... );\n```\n\nNote that mix-in properties and methods will *only* be imported if they aren't already defined in your class.  Meaning, they will not clobber any existing class members.\n\nIf the mix-in classes you are importing have their own parent classes, those should be separately listed in the `__mixins` array.  Meaning, the prototype chain of the mix-ins is not automatically imported -- only the top-level methods and properties on the specified class are merged in.  You'll need to specify parent classes if you want those merged in as well.\n\n## Event Emitters\n\nI find myself frequently inheriting from Node's [EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter) in my classes, so I added a shortcut for it in class-plus.  Simply include a property named `__events` and set it to `true`, and your class will magically become an EventEmitter.  Example:\n\n```javascript\nconst Party = Class({\n\t__events: true\n},\nclass Party {\n\tstart() {\n\t\tconsole.log(\"Let's get this party started!\");\n\t\tthis.emit('dance');\n\t}\n});\n\nvar birthday = new Party();\nbirthday.on('dance', function() {\n\tconsole(\"I'm dancing!\");\n} );\nbirthday.start();\n```\n\nSetting the `__events` property is equivalent to including Node's [EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter) class in your [mix-ins](#mix-ins) array:\n\n```javascript\nconst Party = Class({\n\t__mixins: [ require('events').EventEmitter ]\n},\n... );\n```\n\nSo `__events` is really just a shortcut for that.\n\n## Hooks\n\nTaking event listeners one step further, class-plus introduces an optional \"hook\" system for use in your classes, where custom events can be hooked, and you can run *asynchronous* operations in each listener.  If multiple listeners are registered on a given hook, they are all fired in sequence.  If any listener returns an error, the sequence is aborted, and the error passed to the original caller.\n\nYour listeners can be either callback based, or native [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function) functions.  To enable hooks in your class, simply include a `__hooks` property and set it to `true`.  Example:\n\n```js\nconst Party = Class({ \n\t__hooks: true \n}, \nclass Party {\n\tstart() { console.log(\"The party has finally started.\"); }\n});\nvar birthday = new Party();\n\nbirthday.registerHook( 'prestart', function(item, callback) {\n\t// delay the party by 100ms\n\tsetTimeout( function() { callback(); }, 100 );\n} );\n\nbirthday.fireHook( 'prestart', \"Get ready!\", function(err) {\n\t// all prestart hooks completed, let's go\n\t// this will run about 100ms later\n\tbirthday.start();\n});\n```\n\nThe idea here is similar with events, where one or more listeners can be registered, but in this case the hooks fire in an asynchronous manner, each with a callback to advance to the next listener, or to complete the hook sequence.  In fact, the whole system can be used with native [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function) functions (in Node 8+).  Example:\n\n```js\nconst Party = Class({ \n\t__hooks: true \n}, \nclass Party {\n\tstart() { console.log(\"The party has finally started.\"); }\n});\n\n(async function() {\n\tvar birthday = new Party();\n\n\tbirthday.registerHook( 'prestart', async function(item) {\n\t\t// do something async here\n\t\tawait myfunc();\n\t} );\n\t\n\tawait birthday.fireHook( 'prestart', \"Get ready!\");\n\t\n\t// all async prestart hooks completed, let's go\n\tbirthday.start();\n})();\n```\n\n## Async/Await Conversion\n\nNode.js version 8 introduced native support for the [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)/[await](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await) pattern.  If your class has callback-based methods that you want to auto-convert into async/await, simply declare a `__asyncify` property, and set it to `true`:\n\n```js\nvar Sleeper = Class({\n\t__asyncify: true\n},\nclass Sleeper {\n\tsleep(milliseconds, callback) {\n\t\t// sleep for N milliseconds, then fire callback\n\t\tsetTimeout( function() { callback(); }, milliseconds );\n\t}\n});\n```\n\nThis will automatically detect all your callback-based methods in the class, and then convert them to async using Node's [util.promisify()](https://nodejs.org/api/util.html#util_util_promisify_original), making them instantly ready for async/await.  Example usage:\n\n```js\nvar snooze = new Sleeper();\n\nasync function main() {\n\tawait snooze.sleep( 1000 ); // waits for 1 second here\n\tconsole.log(\"This happened 1 second later!\");\n};\n\nmain();\n```\n\nThe automatic detection mechanism looks inside your method signatures for argument lists ending with the name `callback` (or `cb`).  If you use any other variable name for the callback argument, this will skip over it.  Also, class-plus will take care not asyncify a function that is already async.\n\nIf you only want *some* of your methods to be asyncified, set the `__asyncify` property to an array containing all the method names.  Example:\n\n```js\n{\n\t// only asyncify some methods\n\t__asyncify: [\"sleep\"]\n}\n```\n\nAlternatively, you can set `__asyncify` to a [regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), to match against all of your class method names.  If the pattern matches, the function will be converted.  Example:\n\n```js\n{\n\t// only asyncify some methods\n\t__asyncify: /^(sleep|someOtherFunction)$/\n}\n```\n\nNote that in order for your methods to be async-compatible, they must accept a callback as the final argument, and that callback must be called using the standard Node.js convention (i.e. `(err)` or `(err, result)`).  The error *must* be the first argument sent to the callback (or false/undefined on success), and a result, if any, must be the second argument.\n\n### Async Return Values\n\nIf your callback is fired using the typical `(err, result)` arguments, such as this:\n\n```js\nconst Soda = Class({\n\t__asyncify: true\n},\nclass Soda {\n\tpour(callback) {\n\t\tsetTimeout( function() {\n\t\t\tcallback( null, \"8oz\" );\n\t\t}, 250 );\n\t}\n});\n```\n\nThen you can access the result using async in this way:\n\n```js\nlet drink = new Soda();\n\ntry {\n\tlet result = await drink.pour();\n\tconsole.log(result);\n}\ncatch (err) {\n\tthrow err;\n}\n```\n\nHowever, if your callback has *multiple result arguments*, like this:\n\n```js\nconst Soda = Class({\n\t__asyncify: true\n},\nclass Soda {\n\tpour(callback) {\n\t\tsetTimeout( function() {\n\t\t\tcallback( null, 8, \"oz\" );\n\t\t}, 250 );\n\t}\n});\n```\n\nThey will be returned in an array which you can destruct like this:\n\n```js\nlet drink = new Soda();\n\ntry {\n\tlet [amount, units] = await drink.pour();\n\tconsole.log(amount, units);\n}\ncatch (err) {\n\tthrow err;\n}\n```\n\nFinally, for ultimate control over the async conversion, you can pre-declare the names of your callback arguments in the `__asyncify` property, by setting it to an object containing the function names as keys, and the argument names as array items.  Then, the result can be awaited as a destructed object with named keys.  Here is how to set this up in the class:\n\n```js\nconst Soda = Class({\n\t__asyncify: {\n\t\tpour: ['amount', 'units'] // declare pour() callback arg names here\n\t}\n},\nclass Soda {\n\tpour(callback) {\n\t\tsetTimeout( function() {\n\t\t\tcallback( null, 8, \"oz\" ); // fire callback as usual\n\t\t}, 250 );\n\t}\n});\n```\n\nAnd here is how to await it:\n\n```js\nlet drink = new Soda();\n\ntry {\n\tlet { amount, units } = await drink.pour();\n\tconsole.log(amount, units);\n}\ncatch (err) {\n\tthrow err;\n}\n```\n\nThe idea here is that the calling code can select *which of the arguments it wants*.  For example, we can omit `units` and only fetch `amount`:\n\n```js\nlet { amount } = await drink.pour();\n```\n\n# License\n\n**The MIT License**\n\n*Copyright (c) 2019 - 2022 Joseph Huckaby*\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n","readmeFilename":"README.md"}