Update README

Author: JacobFischer

README.md

@@ -15,9 +15,9 @@ checking when publishing and subscribing to events; or you must write very
 brittle function overloads for _every function_: `on`, `off`, `once`, `emit`,
 etc. This is annoying and tedious.
 
-The aim of this is to leverage TypeScript's generic types to allow for compile-
-time type checking. We also move the events into their own functions, so you
-don't have to inherit or mixin any of our classes, just use these single Event
+The aim of this is to leverage TypeScript's generics to allow for compile-time
+type checking. We also move the events into their own functions, so you don't
+have to inherit or mixin any of our classes, just use these single Event
 emitters. It is also un-opinionated, exposing functional and object oriented
 building blocks in this library so you can use it best works in your project.
 
@@ -65,36 +65,6 @@ event.on((str) => {
 event.emit('some string'); // prints `hey we got the string: some string`
 ```
 
-### Sealed Events
-
-The `Event` class has exposed the member function `emit`, which means any bit
-of code that can your event to listen, can also act as an event emitter.
-
-Often you'll find you do not want to trust bits of code with that
-responsibility. To that end this module exposes an alternative type of events
-and API to generate Events called `SealedEvents` that cannot self emit, and
-a separate emitter function
-
-```ts
-import { createEmitter, SealedEvent } from 'ts-typed-events';
-
-const { event, emit } = createEmitter<string>();
-
-event instanceof SealedEvent; // true
-
-event.on((str) => {
-  console.log('Emitted string:', str);
-});
-
-emit('emitter says hi'); // prints: 'Emitted string: emitter says hi'
-
-'emit' in event; // === false
-```
-
-**Note**: you can also use `createEventEmitter` if you wish the `event` type to
-be `instanceof Event`. However bear in mind that event has access to the
-emitter. This module exposes both for API uniformity.
-
 ### async/await usage
 
 You can register event listeners via traditional callbacks, or if no callback is
@@ -141,6 +111,33 @@ console.log('were any callbacks invoked during the emit?', emitted);
 // printed: `were any callbacks invoked during the emit? false`
 ```
 
+### Combining this within Classes
+
+As this module intends to replace the "built-in" [EventEmitter class], you
+can use it much more freely because it is not a class you **must** inherit like
+with the [EventEmitter class]. To replicate similar functionality you can make
+each event a separate member variable of your.
+
+```ts
+class Dog {
+  private timesBarked = 0;
+  // NOTE: the emitter is private here, and the event is public.
+  // This allows the class to completely control when it emits.
+  private emitBarked = createEmitter();
+
+  public barked = this.emitBarked.event;
+
+  public bark() {
+    this.timesBarked += 1;
+    this.emitBarked();
+  }
+}
+
+const dog = new Dog();
+dog.barked.on(() => console.log('The dog barked!'));
+dog.bark(); // prints: `The dog barked!`;
+```
+
 ### Alternative Syntax
 
 The method, `createEmitter`, returns the emitter function, with
@@ -161,33 +158,36 @@ emit(); // prints `did we get something?: undefined`
 console.log(emit === emit.emit); // print `true`
 ```
 
-### Combining this within Classes
+#### Sealed Events
 
-As this module intends to replace the "built-in" [EventEmitter class], you
-can use it much more freely because it is not a class you **must** inherit like
-with the [EventEmitter class]. To replicate similar functionality you can make
-each event a separate member variable of your.
+The `Event` class has exposed the member function `emit`, which means any bit
+of code that can your event to listen, can also act as an event emitter.
+
+Often you'll find you do not want to trust bits of code with that
+responsibility. To that end this module exposes an alternative type of events
+and API to generate Events called `SealedEvents` that cannot self emit, and
+a separate emitter function
 
 ```ts
-class Dog {
-  private timesBarked = 0;
-  // NOTE: the emitter is private here, and the event is public.
-  // This allows the class to completely control when it emits.
-  private emitBarked = createEmitter();
+import { createEmitter, SealedEvent } from 'ts-typed-events';
 
-  public barked = this.emitBarked.event;
+const { event, emit } = createEmitter<BigInt>();
 
-  public bark() {
-    this.timesBarked += 1;
-    this.emitBarked();
-  }
-}
+event instanceof SealedEvent; // true
 
-const dog = new Dog();
-dog.barked.on(() => console.log('The dog barked!'));
-dog.bark(); // prints: `The dog barked!`;
+event.on((int) => {
+  console.log('Emitted BigInt:', int);
+});
+
+emit(1337n); // prints: 'Emitted BigInt: 1337'
+
+'emit' in event; // === false
 ```
 
+**Note**: you can also use `createEventEmitter` if you wish the `event` type to
+be `instanceof Event`. However bear in mind that event has access to the
+emitter. This module exposes both for API uniformity.
+
 ## Other Notes
 
 This library leverages TypeScript's interfaces and generics very heavily to do