Draft of a new tree shakeable API

Author: jwagner

README.md

@@ -22,59 +22,56 @@ Created something awesome with simplex-noise? Let me know so I can add it to the
 
 ```npm i -S simplex-noise```
 
-## Usage
+## Usage Examples
+
+### ES Module Import
 
 ```javascript
-// when using es modules
-import SimplexNoise from 'simplex-noise';
-// when using commonjs
-const {SimplexNoise} = require('simplex-noise');
+// when using ES modules
+import { noiseFunction2D } from 'simplex-noise';
 ```
 
-By default simplex-noise.js will use Math.random() to seed the noise.
+### CommonJS Require
+
 ```javascript
-// initializing a new simplex instance
-// do this only once as it is relatively expensive
-const simplex = new SimplexNoise(),
-    value2d = simplex.noise2D(x, y),
-    value3d = simplex.noise3D(x, y, z),
-    value4d = simplex.noise4D(x, y, z, w);
+const { noiseFunction2D } = require('simplex-noise');
 ```
 
-You can also pass in a seed string which will then be used to initialize
-the noise using the built in alea PRNG.
-```javascript
-const simplex = new SimplexNoise('seed'),
-    value2d = simplex.noise2D(x, y),
-    sameSeed = new SimplexNoise('seed'),
-    differentSeed = new SimplexNoise('different seed');
+### 2D
 
-sameSeed.noise2D(x, y) === value2d
-differentSeed.noise2D(x, y) !== value2d
+```
+const noise2D = noiseFunction2D();
+console.log(noise2D(x, y));
 ```
 
-You can also pass an alternative random function to the constructor that is
-used to build the permutation table.
-This can be used with a custom pseudo random number generator:
+### 3D
 
-```javascript
-const random = new Alea(seed),
-    simplex = new SimplexNoise(random),
-    value2d = simplex.noise2D(x, y);
+```
+const noise3D = noiseFunction3D();
+console.log(noise3D(x, y, z));
 ```
 
-The ALEA PRNG can be found in the npm package [alea](https://npmjs.org/package/alea).
+### 4D
 
-## node.js
+```
+const noise4D = noiseFunction4D();
+console.log(noise4D(x, y, z, w));
+```
 
-Node.js is also supported, you can install the package using [npm](https://npmjs.org/package/simplex-noise).
+### Using a seed value
 
-```javascript
-const SimplexNoise = require('simplex-noise'),
-    simplex = new SimplexNoise(Math.random),
-    value2d = simplex.noise2D(x, y);
+By default simplex-noise.js will use Math.random() to seed the noise.
+You can pass in a PRNG function to use your own seed value.
+
+```
+import Alea from 'alea';
+const alea = new Alea('seed');
+const noise2D = noiseFunction2D(alea);
+console.log(noise2D(x, y));
 ```
 
+The ALEA PRNG used in the example above can be found in the [alea](https://npmjs.org/package/alea) npm package.
+
 ## Benchmarks
 
 simplex-noise.js is reasonably quick.

commonjs-wrapper.ts

@@ -1,11 +1,11 @@
-import SimplexNoise from 'simplex-noise';
+import {noiseFunction3D} from 'simplex-noise';
 
 const canvas =  document.createElement('canvas');
 canvas.width = 512;
 canvas.height = 512;
 document.body.appendChild(canvas);
 
-const simplex = new SimplexNoise(),
+const noise3D = noiseFunction3D(),
   ctx = canvas.getContext('2d'),
   imgdata = ctx.getImageData(0, 0, canvas.width, canvas.height),
   width = imgdata.width,
@@ -16,8 +16,8 @@ function render() {
   const t = performance.now()/1000;
   for (var x = 0; x < width; x++) {
     for (var y = 0; y < height; y++) {
-      var r = simplex.noise3D(x / 16, y / 16, t) * 0.5 + 0.5;
-      var g = simplex.noise3D(x / 8, y / 8, t) * 0.5 + 0.5;
+      var r = noise3D(x / 16, y / 16, t) * 0.5 + 0.5;
+      var g = noise3D(x / 8, y / 8, t) * 0.5 + 0.5;
       data[(x + y * width) * 4 + 0] = r * 255;
       data[(x + y * width) * 4 + 1] = (r + g) * 200;
       data[(x + y * width) * 4 + 2] = 0;