Updated the README.md and the TSDoc.

Author: aryan-programmer

README.md

@@ -2,6 +2,48 @@
 
 This library can be used to achieve multiple inheritance in JavaScript, but it sets itself apart from other libraries for multiple inheritance because it isolates the base classes and prevents the properties and methods from colliding, while still allowing easy access to the properties and methods of the base classes.
 
+## Installation
+
+Simply run:
+
+```
+npm add extend-bases
+```
+
+Or:
+
+```
+yarn add extend-bases
+```
+
+To import:
+
+```typescript
+import {bases, defineProperties, isInstanceOf} from "extend-bases";
+```
+
+Or:
+
+```typescript
+const {bases, defineProperties, isInstanceOf} = require("extend-bases");
+```
+
+## Getting started
+
+To inherit from multiple bases simply extend from `bases(Class1, Class2, ...)`. In the constructor pass the <b>*instances*</b> of the classes to the `super` constructor.
+
+Then you can access the base properties and methods directly from `this.`, the first class with that property or method will be given precedence. 
+
+To access a particular base use `this.bases[index]`.
+
+Replace all instances of `v instanceof Class` with `isInstanceOf(v, Class)`, it’s just that simple.
+
+## For more details
+
+- Read the [Handy manual](https://github.com/aryan-programmer/extend-bases/wiki/Handy-Manual), it’s very simple & small and gives enough information to get started.
+- Then read the [Documentation](https://github.com/aryan-programmer/extend-bases/wiki/Documentation). it’s not too big and easy to go through.
+- Then, if you have enough time or are interested, read the tests and source code of the project.
+
 ## Implementation details
 
 This library uses Proxies, so sadly no IE11 support, but otherwise this library also imports es-shims for `Reflect.ownKeys`(ES6 but used very often and an es-shim exists for it) and `Array.prototype.flatMap`(ES2019, very new), which were found to be the bottlenecks, for some browsers.
@@ -11,3 +53,7 @@ This library uses proxies for easy access in the class instances, and it merges
 ## TypeScript support
 
 The library is by default written in TypeScript, which you all should be using if you aren’t, for great code completion. The details of the TypeScript definitions are a bit fiddly, so it’s best not to worry about them, they work<small>, or you can just look at the source code</small>.
+
+## Contributing
+
+Feel free to open a pull request, fix bugs, or read the source code. It’s all up to you.

index.ts

@@ -33,7 +33,7 @@ type UnionToIntersection<U> =
 	(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 
 /**
- * The type of an array containing the instances of specified constructors.
+ * Specifies that the array contains all the instances of specified constructors in order.
  */
 type InstancesArray<Ts extends Ctor[]> = {
 	[I in keyof Ts]: Ts[I] extends Ctor ? InstanceType<Ts[I]> : never;
@@ -47,7 +47,7 @@ type HasBasesArray<TBases extends Ctor[]> = {
 }
 
 /**
- * Specifies that the object is an intersection of all of the bases.
+ * Specifies that the object is an intersection of all of the bases, and has an array containing all of the base instances.
  */
 type HasBases<TBases extends Ctor[]> =
 	UnionToIntersection<AnyInstancesOf<TBases>> &
@@ -108,6 +108,7 @@ function setPrototypeToProxy<TBases extends Ctor[]> (
  * But, this library isolates the derived and base classes, ie prevents collision of their properties and methods.
  * Thus, this problem can be avoided by using the <code>defineProperties</code> method from this library, if you use the <code>bases</code> methods as well.
  * @param baseClasses The base classes to be inherited.
+ * @return A constructor taking in the *instances* of the base classes.
  *
  * @example
  * class Activatable {
@@ -263,7 +264,7 @@ function bases<TBases extends Ctor[]> (...baseClasses: TBases):
 
 /**
  * Defines the properties on the given object, the key represents the name of the property and the value as the, well, value.
- * Moreover, if the property name if prefixed with "readonly " then the property will be set to be readonly, ie non-writable.
+ * Moreover, if the property name if prefixed with `readonly` then the property will be set to be readonly, ie non-writable, ie any attempts to edit it in strict mode will fail with a `TypeError`.
  *
  * Use this function to set the properties of the objects inheriting from multiple base classes.
  *
@@ -277,7 +278,7 @@ function bases<TBases extends Ctor[]> (...baseClasses: TBases):
  *     "readonly <>": <value>, // Define a readonly property on `this` with the name <prop> and value <value>, readonly ie any attempts to edit it in strict mode will fail with a TypeError.
  * });
  */
-function defineProperties<T extends object> (v: T, props: { [key: string]: any, }) {
+function defineProperties<T extends object> (v: T, props: { [key: string]: any }) {
 	for (const prop of Reflect.ownKeys(props)) {
 		if (typeof prop !== "string") {
 			continue;
@@ -304,6 +305,7 @@ function defineProperties<T extends object> (v: T, props: { [key: string]: any,
  *
  * @param v The object to check.
  * @param cls The constructor of the class to check.
+ * @return Whether or not the object `v` is an instance of the given class `cls`.
  */
 function isInstanceOf<T extends object, TBase extends Ctor> (v: T, cls: TBase): boolean {
 	if (v instanceof cls) {

package.json

@@ -2,7 +2,7 @@
   "name": "extend-bases",
   "version": "1.0.0",
   "description": "A simple library for multiple inheritance in JavaScript.",
-  "repository": "a",
+  "repository": "https://github.com/aryan-programmer/extend-bases",
   "author": "[email protected]",
   "license": "MIT",
   "private": false,