From 91d00a46fd3917991e315b96ffee422fc23fea16 Mon Sep 17 00:00:00 2001
From: Fred Christensen <fred@ifit.com>
Date: Fri, 26 Jan 2018 13:07:45 -0700
Subject: [PATCH 1/5] Possible suggestions for clarity

---
 src/neural-network.js | 204 +++++++++++++++++++++++++-----------------
 test/base/options.js  |  14 ---
 2 files changed, 124 insertions(+), 94 deletions(-)

diff --git a/src/neural-network.js b/src/neural-network.js
index b7e43a64d..f5b9b9aca 100644
--- a/src/neural-network.js
+++ b/src/neural-network.js
@@ -15,23 +15,23 @@ import Thaw from 'thaw.js';
 export default class NeuralNetwork {
   static get trainDefaults() {
     return {
-      iterations: 20000,
-      errorThresh: 0.005,
-      log: false,
-      logPeriod: 10,
-      learningRate: 0.3,
-      callback: null,
-      callbackPeriod: 10
+      iterations: 20000,    // the maximum times to iterate the training data
+      errorThresh: 0.005,   // the acceptable error percentage from training data
+      log: false,           // true to use console.log, when a function is supplied it is used
+      logPeriod: 10,        // iterations between logging out
+      learningRate: 0.3,    // multiply's against the input and the delta then adds to momentum
+      momentum: 0.1,        // multiply's against the specified "change" then adds to learning rate for change
+      callback: null,       // a periodic call back that can be triggered while training
+      callbackPeriod: 10,   // the number of iterations through the training data between callback calls
+      timeout: Infinity     // the max number of milliseconds to train for
     };
   }
 
   static get defaults() {
     return {
-      learningRate: 0.3,
-      momentum: 0.1,
-      binaryThresh: 0.5,
-      hiddenLayers: null,
-      activation: 'sigmoid'
+      binaryThresh: 0.5,     // ¯\_(ツ)_/¯
+      hiddenLayers: [3],     // array of ints for the sizes of the hidden layers in the network
+      activation: 'sigmoid'  // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']
     };
   }
 
@@ -39,6 +39,11 @@ export default class NeuralNetwork {
     Object.assign(this, this.constructor.defaults, options);
     this.hiddenSizes = options.hiddenLayers;
 
+    let backCompat = {};
+    if (options.learningRate) backCompat.learningRate = options.learningRate;
+    if (options.momentum) backCompat.momentum = options.momentum;
+    this.trainOpts = Object.assign({}, this.constructor.trainDefaults, backCompat);
+
     this.sizes = null;
     this.outputLayer = null;
     this.biases = null; // weights for bias nodes
@@ -60,10 +65,11 @@ export default class NeuralNetwork {
 
   /**
    *
-   * @param {Number[]} sizes
+   * Expects this.sizes to have been set
    */
-  initialize(sizes) {
-    this.sizes = sizes;
+  _initialize() {
+    if (!this.sizes) throw new Error ('Sizes must be set before initializing')
+
     this.outputLayer = this.sizes.length - 1;
     this.biases = []; // weights for bias nodes
     this.weights = [];
@@ -96,6 +102,10 @@ export default class NeuralNetwork {
     this.setActivation();
   }
 
+  /**
+   *
+   * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+   */
   setActivation() {
     switch (this.activation) {
       case 'sigmoid':
@@ -255,26 +265,66 @@ export default class NeuralNetwork {
   /**
    *
    * @param data
-   * @returns sizes
+   * Verifies network sizes are initilaized
+   * If they are not it will initialize them based off the data set.
    */
-  _getSizesFromData(data) {
-    let sizes = [];
-    let inputSize = data[0].input.length;
-    let outputSize = data[0].output.length;
-    let hiddenSizes = this.hiddenSizes;
-    if (!hiddenSizes) {
-      sizes.push(Math.max(3, Math.floor(inputSize / 2)));
+  _verifyIsInitialized(data) {
+    if (this.sizes) return;
+
+    this.sizes = [];
+    this.sizes.push(data[0].input.length);
+    if (!this.hiddenSizes) {
+      this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));
     } else {
-      hiddenSizes.forEach(size => {
-        sizes.push(size);
+      this.hiddenSizes.forEach(size => {
+        this.sizes.push(size);
       });
     }
+    this.sizes.push(data[0].output.length)
 
-    sizes.unshift(inputSize);
-    sizes.push(outputSize);
-    return sizes;
+    this._initialize();
   }
 
+  /**
+   *
+   * @param options
+   *    Supports all `trainDefaults` properties
+   *    also supports:
+   *       learningRate: (number),
+   *       momentum: (number),
+   *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+   */
+  _updateTrainingOptions(opts) {
+    if (opts.iterations) { this.trainOpts.iterations = opts.iterations; }
+    if (opts.errorThresh) { this.trainOpts.errorThresh = opts.errorThresh; }
+    if (opts.log) { this._setLogMethod(opts.log); }
+    if (opts.logPeriod) { this.trainOpts.logPeriod = opts.logPeriod; }
+    if (opts.learningRate) { this.trainOpts.learningRate = opts.learningRate; }
+    if (opts.momentum) { this.trainOpts.momentum = opts.momentum; }
+    if (opts.callback) { this.trainOpts.callback = opts.callback; }
+    if (opts.callbackPeriod) { this.trainOpts.callbackPeriod = opts.callbackPeriod; }
+    if (opts.timeout) { this.trainOpts.callbackPeriod = opts.timeout; }
+    if (opts.activation) { this.activation = opts.activation; }
+  }
+
+  /**
+   *
+   *  Gets JSON of trainOpts object
+   *    NOTE: Activation is stored directly on JSON object and not in the training options
+   */
+  _getTrainOptsJSON() {
+    let results = {}
+    if (this.trainOpts.iterations) { results.iterations = this.trainOpts.iterations; }
+    if (this.trainOpts.errorThresh) { results.errorThresh = this.trainOpts.errorThresh; }
+    if (this.trainOpts.logPeriod) { results.logPeriod = this.trainOpts.logPeriod; }
+    if (this.trainOpts.learningRate) { results.learningRate = this.trainOpts.learningRate; }
+    if (this.trainOpts.momentum) { results.momentum = this.trainOpts.momentum; }
+    if (this.trainOpts.callback) { results.callback = this.trainOpts.callback; }
+    if (this.trainOpts.callbackPeriod) { results.callbackPeriod = this.trainOpts.callbackPeriod; }
+    if (this.trainOpts.timeout) { results.timeout = this.trainOpts.timeout; }
+    if (this.trainOpts.log) { results.log = true; }
+    return results;
+  }
 
   /**
    *
@@ -284,8 +334,13 @@ export default class NeuralNetwork {
    * @returns error
    */
   _setLogMethod(log) {
-    if (log) return console.log;
-    return false;
+    if (typeof log === 'function'){
+      this.trainOpts.log = log;
+    } else if (log) {
+      this.trainOpts.log = console.log;
+    } else {
+      this.trainOpts.log = false;
+    }
   }
 
   /**
@@ -294,10 +349,10 @@ export default class NeuralNetwork {
    * @param learning Rate
    * @returns error
    */
-  _calculateTrainingError(data, learningRate) {
+  _calculateTrainingError(data) {
     let sum = 0;
     for (let i = 0; i < data.length; ++i) {
-      sum += this.trainPattern(data[i].input, data[i].output, learningRate);
+      sum += this._trainPattern(data[i].input, data[i].output);
     }
     return sum / data.length;
   }
@@ -307,42 +362,39 @@ export default class NeuralNetwork {
    * @param status { iterations: number, error: number}
    * @param options
    */
-  _checkTrainingTick(data, status, options) {
+  _trainingTick(data, status) {
     status.iterations++;
-    status.error = this._calculateTrainingError(data, options.learningRate);
+    status.error = this._calculateTrainingError(data);
 
-    if (options.log && (status.iterations % options.logPeriod === 0)) {
-      options.log(`iterations: ${status.iterations}, training error: ${status.error}`);
+    if (this.trainOpts.log && (status.iterations % this.trainOpts.logPeriod === 0)) {
+      this.trainOpts.log(`iterations: ${status.iterations}, training error: ${status.error}`);
     }
 
-    if (options.callback && (status.iterations % options.callbackPeriod === 0)) {
-      options.callback(Object.assign(status));
+    if (this.trainOpts.callback && (status.iterations % this.trainOpts.callbackPeriod === 0)) {
+      this.trainOpts.callback(Object.assign(status));
     }
   }
 
   /**
    *
    * @param data
-   * @param _options
+   * @param options
    * @returns {{error: number, iterations: number}}
    */
-  train(data, _options = {}) {
-    const options = Object.assign({}, this.constructor.trainDefaults, _options);
+  train(data, options = {}) {
+    this._updateTrainingOptions(options);
     data = this.formatData(data);
-    options.log = this._setLogMethod(options.log);
-    options.learningRate = _options.learningRate || this.learningRate || options.learningRate;
-    var status = {
+    const endTime = Date.now() + this.trainOpts.timeout;
+
+    const status = {
       error: 1,
       iterations: 0
     };
 
-    if (this.sizes === null) {
-      let sizes = this._getSizesFromData(data);
-      this.initialize(sizes);
-    }
+    this._verifyIsInitialized(data);
 
-    while ( status.iterations < options.iterations && status.error > options.errorThresh) {
-      this._checkTrainingTick(data, status, options);
+    while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {
+      this._trainingTick(data, status);
     }
 
     return status;
@@ -351,41 +403,33 @@ export default class NeuralNetwork {
   /**
    *
    * @param data
-   * @param _options
+   * @param options
    * @param cb
    * @returns {{error: number, iterations: number}}
    */
-  trainAsync(data, _options = {}) {
+  trainAsync(data, options = {}) {
     return new Promise((resolve, reject) => {
-      const options = Object.assign({}, this.constructor.trainDefaults, _options);
+      this._updateTrainingOptions(options);
       data = this.formatData(data);
-      options.log = this._setLogMethod(options.log);
-      options.learningRate = _options.learningRate || this.learningRate || options.learningRate;
-      let endTime = Date.now() + options.trainTimeMs;
+      const endTime = Date.now() + this.trainOpts.timeout;
 
-      let status = {
+      const status = {
         error: 1,
         iterations: 0
       };
 
-      if (this.sizes === null) {
-        let sizes = this._getSizesFromData(data);
-        this.initialize(sizes);
-      }
+      this._verifyIsInitialized(data);
 
-      const items = new Array(options.iterations);
+      const items = new Array(this.trainOpts.iterations);
       const thaw  = new Thaw(items, {
         delay: true,
         each: () => {
-          this._checkTrainingTick(data, status, options);
-
-          if (status.error < options.errorThresh) {
+          this._trainingTick(data, status);
+          if (status.error < this.trainOpts.errorThresh || Date.now() > endTime) {
             thaw.stop();
           }
         },
-        done: () => {
-          resolve(status);
-        }
+        done: () => { resolve(status); }
       });
 
       thaw.tick();
@@ -396,17 +440,15 @@ export default class NeuralNetwork {
    *
    * @param input
    * @param target
-   * @param learningRate
    */
-  trainPattern(input, target, learningRate) {
-    learningRate = learningRate || this.learningRate;
+  _trainPattern(input, target) {
 
     // forward propagate
     this.runInput(input);
 
     // back propagate
     this.calculateDeltas(target);
-    this.adjustWeights(learningRate);
+    this.adjustWeights();
 
     let error = mse(this.errors[this.outputLayer]);
     return error;
@@ -514,9 +556,9 @@ export default class NeuralNetwork {
 
   /**
    *
-   * @param learningRate
+   * Changes weights of networks
    */
-  adjustWeights(learningRate) {
+  adjustWeights() {
     for (let layer = 1; layer <= this.outputLayer; layer++) {
       let incoming = this.outputs[layer - 1];
 
@@ -526,13 +568,13 @@ export default class NeuralNetwork {
         for (let k = 0; k < incoming.length; k++) {
           let change = this.changes[layer][node][k];
 
-          change = (learningRate * delta * incoming[k])
-            + (this.momentum * change);
+          change = (this.trainOpts.learningRate * delta * incoming[k])
+            + (this.trainOpts.momentum * change);
 
           this.changes[layer][node][k] = change;
           this.weights[layer][node][k] += change;
         }
-        this.biases[layer][node] += learningRate * delta;
+        this.biases[layer][node] += this.trainOpts.learningRate * delta;
       }
     }
   }
@@ -735,7 +777,8 @@ export default class NeuralNetwork {
       layers,
       outputLookup:!!this.outputLookup,
       inputLookup:!!this.inputLookup,
-      activation: this.activation
+      activation: this.activation,
+      trainOpts: this._getTrainOptsJSON()
     };
   }
 
@@ -745,7 +788,8 @@ export default class NeuralNetwork {
    * @returns {NeuralNetwork}
    */
   fromJSON (json) {
-    this.initialize (json.sizes);
+    this.sizes = json.sizes
+    this._initialize();
 
     for (let i = 0; i <= this.outputLayer; i++) {
       let layer = json.layers[i];
@@ -765,7 +809,7 @@ export default class NeuralNetwork {
         }
       }
     }
-
+    this._updateTrainingOptions(json.trainOpts)
     this.setActivation();
     return this;
   }
diff --git a/test/base/options.js b/test/base/options.js
index 04eebbff0..7330f039b 100644
--- a/test/base/options.js
+++ b/test/base/options.js
@@ -125,29 +125,15 @@ describe('async neural network options', () => {
       }).catch(err => {
         assert.ok(false, err.toString())
       });
-
   }).timeout(5000);
 })
 
 
 describe('log', () => {
   let logCalled = false;
-  let oldLog;
 
   beforeEach(() => { logCalled = false; });
 
-  before(() => {
-    oldLog = console.log;
-    console.log = () => {
-      oldLog(arguments);
-      logCalled = true;
-    }
-  })
-
-  after(() => {
-    console.log = oldLog;
-  })
-
   function logFunction(str) {
     logCalled = true;
   }

From e9f1401e23c86f90580f207e0722092f90d68b24 Mon Sep 17 00:00:00 2001
From: Fred Christensen <fred@ifit.com>
Date: Sat, 27 Jan 2018 21:24:33 -0700
Subject: [PATCH 2/5] Updates

Made setActivation() accept a param to be more friendly for other users

Created log test class

Moved the options tests that were for training options into the training options tests

made async training options tests.

Updates some readme stuff
---
 README.md              |  16 ++--
 src/neural-network.js  |  20 ++--
 test/README.md         |   2 +-
 test/base/hash.js      |   2 +-
 test/base/json.js      |   8 ++
 test/base/log.js       |  41 ++++++++
 test/base/options.js   | 210 +++++++++++++++--------------------------
 test/base/trainopts.js | 147 +++++++++++++++++++++++++++--
 8 files changed, 286 insertions(+), 160 deletions(-)
 create mode 100644 test/base/log.js

diff --git a/README.md b/README.md
index dc93fd055..6a5bab927 100644
--- a/README.md
+++ b/README.md
@@ -129,11 +129,15 @@ var output = net.run({ r: 1, g: 0.4, b: 0 });  // { white: 0.81, black: 0.18 }
 
 ```javascript
 net.train(data, {
-  errorThresh: 0.005,  // error threshold to reach
-  iterations: 20000,   // maximum training iterations
-  log: true,           // console.log() progress periodically
-  logPeriod: 10,       // number of iterations between logging
-  learningRate: 0.3    // learning rate
+      iterations: 20000,    // the maximum times to iterate the training data
+      errorThresh: 0.005,   // the acceptable error percentage from training data
+      log: false,           // true to use console.log, when a function is supplied it is used
+      logPeriod: 10,        // iterations between logging out
+      learningRate: 0.3,    // scales with delta to effect traiing rate
+      momentum: 0.1,        // scales with next layer's change value 
+      callback: null,       // a periodic call back that can be triggered while training
+      callbackPeriod: 10,   // the number of iterations through the training data between callback calls
+      timeout: Infinity     // the max number of milliseconds to train for
 });
 ```
 
@@ -143,6 +147,7 @@ By default training won't let you know how its doing until the end, but set `log
 
 The learning rate is a parameter that influences how quickly the network trains. It's a number from `0` to `1`. If the learning rate is close to `0` it will take longer to train. If the learning rate is closer to `1` it will train faster but it's in danger of training to a local minimum and performing badly on new data.(_Overfitting_) The default learning rate is `0.3`.
 
+The momentum is similar to learning rate, expecting a value from `0` to `1` as well but it is multiplied against the next level's change value.  The default value is `0.1`
 
 ### Async Training
 `trainAsync()` takes the same arguments as train (data and options).  Instead of returning the results object from training it returns a promise that when resolved will return the training results object.
@@ -156,7 +161,6 @@ The learning rate is a parameter that influences how quickly the network trains.
     })
     .catch(handleError);
 ```
-
 With multiple networks you can train in parallel like this:
 
 ```javascript
diff --git a/src/neural-network.js b/src/neural-network.js
index f5b9b9aca..e348d36de 100644
--- a/src/neural-network.js
+++ b/src/neural-network.js
@@ -38,11 +38,8 @@ export default class NeuralNetwork {
   constructor(options = {}) {
     Object.assign(this, this.constructor.defaults, options);
     this.hiddenSizes = options.hiddenLayers;
-
-    let backCompat = {};
-    if (options.learningRate) backCompat.learningRate = options.learningRate;
-    if (options.momentum) backCompat.momentum = options.momentum;
-    this.trainOpts = Object.assign({}, this.constructor.trainDefaults, backCompat);
+    this.trainOpts = {};
+    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));
 
     this.sizes = null;
     this.outputLayer = null;
@@ -106,7 +103,8 @@ export default class NeuralNetwork {
    *
    * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
    */
-  setActivation() {
+  setActivation(activation) {
+    this.activation = (activation) ? activation : this.activation;
     switch (this.activation) {
       case 'sigmoid':
         this.runInput = this.runInput || this.runInputSigmoid;
@@ -294,7 +292,7 @@ export default class NeuralNetwork {
    *       momentum: (number),
    *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
    */
-  _updateTrainingOptions(opts) {
+  updateTrainingOptions(opts) {
     if (opts.iterations) { this.trainOpts.iterations = opts.iterations; }
     if (opts.errorThresh) { this.trainOpts.errorThresh = opts.errorThresh; }
     if (opts.log) { this._setLogMethod(opts.log); }
@@ -303,7 +301,7 @@ export default class NeuralNetwork {
     if (opts.momentum) { this.trainOpts.momentum = opts.momentum; }
     if (opts.callback) { this.trainOpts.callback = opts.callback; }
     if (opts.callbackPeriod) { this.trainOpts.callbackPeriod = opts.callbackPeriod; }
-    if (opts.timeout) { this.trainOpts.callbackPeriod = opts.timeout; }
+    if (opts.timeout) { this.trainOpts.timeout = opts.timeout; }
     if (opts.activation) { this.activation = opts.activation; }
   }
 
@@ -382,7 +380,7 @@ export default class NeuralNetwork {
    * @returns {{error: number, iterations: number}}
    */
   train(data, options = {}) {
-    this._updateTrainingOptions(options);
+    this.updateTrainingOptions(options);
     data = this.formatData(data);
     const endTime = Date.now() + this.trainOpts.timeout;
 
@@ -409,7 +407,7 @@ export default class NeuralNetwork {
    */
   trainAsync(data, options = {}) {
     return new Promise((resolve, reject) => {
-      this._updateTrainingOptions(options);
+      this.updateTrainingOptions(options);
       data = this.formatData(data);
       const endTime = Date.now() + this.trainOpts.timeout;
 
@@ -809,7 +807,7 @@ export default class NeuralNetwork {
         }
       }
     }
-    this._updateTrainingOptions(json.trainOpts)
+    this.updateTrainingOptions(json.trainOpts)
     this.setActivation();
     return this;
   }
diff --git a/test/README.md b/test/README.md
index d59a69bd8..f86b66967 100644
--- a/test/README.md
+++ b/test/README.md
@@ -12,7 +12,7 @@ Then you can run all tests using `npm test`.
 Run the unit tests with:
 
 ```
-npm test
+npm run test
 ```
 
 See [package.json](../package.json) for more testing examples.
diff --git a/test/base/hash.js b/test/base/hash.js
index ba6cad0ec..6632097d7 100644
--- a/test/base/hash.js
+++ b/test/base/hash.js
@@ -2,7 +2,7 @@ import assert from 'assert';
 import brain from '../../src';
 
 describe('hash input and output', () => {
-  it ('runs correctly with array input and output', () => {
+  it('runs correctly with array input and output', () => {
     let net = new brain.NeuralNetwork();
 
     net.train([
diff --git a/test/base/json.js b/test/base/json.js
index 8489767c8..48c685518 100644
--- a/test/base/json.js
+++ b/test/base/json.js
@@ -20,12 +20,14 @@ describe('JSON', () => {
   const input = {'0' : Math.random(), b: Math.random()};
   describe('.toJSON()', () => {
     describe('.layers', () => {
+
       it('layer count is correct', () => {
         assert.equal(serialized.layers.length, 3);
         originalNet.sizes.forEach((size, i) => {
           assert.equal(size, Object.keys(serialized.layers[i]).length);
         });
       });
+
       describe('input layer', () => {
         const inputLayer = serialized.layers[0];
         it('is empty, but describes input', () => {
@@ -37,6 +39,7 @@ describe('JSON', () => {
           assert(Object.keys(inputLayer['b']).length === 0);
         });
       });
+
       describe('hidden layers', () => {
         it('are populated exactly from original net', () => {
           assert.equal(serialized.layers[1][0].bias, originalNet.biases[1][0]);
@@ -47,12 +50,14 @@ describe('JSON', () => {
         });
       });
     });
+
     describe('.activation', () => {
       it('exports correctly', () => {
         assert.equal(serialized.activation, originalNet.activation);
       });
     });
   });
+
   describe('.fromJSON()', () => {
     describe('importing values', () => {
       describe('.layers', () => {
@@ -61,6 +66,7 @@ describe('JSON', () => {
           assert.equal(serializedNet.biases['1'].length, 3);
           assert.equal(serializedNet.weights.length, 3);
         });
+
         describe('hidden layers', () => {
           it('are populated exactly from serialized', () => {
             assert.equal(serializedNet.biases[1][0], serialized.layers[1][0].bias);
@@ -71,12 +77,14 @@ describe('JSON', () => {
           });
         });
       });
+
       describe('.activation', () => {
         it('exports correctly', () => {
           assert.equal(serializedNet.activation, serialized.activation);
         });
       });
     });
+
     it('can run originalNet, and serializedNet, with same output', () => {
       const output1 = originalNet.run(input);
       const output2 = serializedNet.run(input);
diff --git a/test/base/log.js b/test/base/log.js
new file mode 100644
index 000000000..247d1abdf
--- /dev/null
+++ b/test/base/log.js
@@ -0,0 +1,41 @@
+import assert from 'assert';
+import brain from '../../src';
+
+describe('log', () => {
+  let logCalled = false;
+
+  beforeEach(() => { logCalled = false; });
+
+  function logFunction(str) {
+    logCalled = true;
+  }
+
+  function trainWithLog(log, expected) {
+    let net = new brain.NeuralNetwork();
+    net.train(
+      [ { input: [0], output: [0] } ],
+      { log: log, logPeriod: 1, iterations: 1 }
+    );
+    assert.equal(logCalled, expected)
+  }
+
+  function trainWithLogAsync(log, expected, done) {
+    let net = new brain.NeuralNetwork();
+    net
+      .trainAsync(
+        [ {input: [0], output: [0]} ],
+        { log: log, logPeriod: 1, iterations: 1 }
+      )
+      .then(res => {
+        assert.equal(logCalled, expected);
+        done();
+      })
+      .catch(err => { assert.ok(false, err.toString()) });
+  }
+
+  it('should call log method', () => { trainWithLog(logFunction, true); });
+  it('should not call log method', () => { trainWithLog(false, false); });
+
+  it('ASYNC should call log method', done => { trainWithLogAsync(logFunction, true, done); }).timeout(5000);
+  it('ASYNC should not call log method', done => { trainWithLogAsync(false, false, done); }).timeout(5000);
+});
diff --git a/test/base/options.js b/test/base/options.js
index 7330f039b..18a62fee7 100644
--- a/test/base/options.js
+++ b/test/base/options.js
@@ -5,7 +5,6 @@ describe('neural network options', () => {
 
   it('hiddenLayers', () => {
     let net = new brain.NeuralNetwork({ hiddenLayers: [8, 7] });
-
     net.train([
       { input: [0, 0], output: [0] },
       { input: [0, 1], output: [1] },
@@ -14,7 +13,6 @@ describe('neural network options', () => {
     ]);
 
     let json = net.toJSON();
-
     assert.equal(json.layers.length, 4);
     assert.equal(Object.keys(json.layers[1]).length, 8);
     assert.equal(Object.keys(json.layers[2]).length, 7);
@@ -22,7 +20,6 @@ describe('neural network options', () => {
 
   it('hiddenLayers default expand to input size', () => {
     let net = new brain.NeuralNetwork();
-
     net.train([
       { input: [0, 0, 1, 1, 1, 1, 1, 1, 1], output: [0]},
       { input: [0, 1, 1, 1, 1, 1, 1, 1, 1], output: [1]},
@@ -31,141 +28,84 @@ describe('neural network options', () => {
     ]);
 
     let json = net.toJSON();
-
     assert.equal(json.layers.length, 3);
     assert.equal(Object.keys(json.layers[1]).length, 4, `9 input units should be 4 hidden not ${Object.keys(json.layers[1]).length}`);
   });
-
-  it('learningRate - higher learning rate should train faster', () => {
-    let data = [
-      { input: [0, 0], output: [0] },
-      { input: [0, 1], output: [1] },
-      { input: [1, 0], output: [1] },
-      { input: [1, 1], output: [1] }
-    ];
-
-    let net = new brain.NeuralNetwork();
-    let res = net.train(data, { learningRate: 0.5 });
-
-    let net2 = new brain.NeuralNetwork();
-    let res2 = net2.train(data, { learningRate: 0.8 });
-
-    assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} should be greater than ${res2.iterations * 1.1}`);
-  });
-
-
-  it('momentum - higher momentum should train faster', () => {
-    let data = [
-      { input: [0, 0], output: [0] },
-      { input: [0, 1], output: [1] },
-      { input: [1, 0], output: [1] },
-      { input: [1, 1], output: [1] }
-    ];
-
-    let net = new brain.NeuralNetwork({ momentum: 0.1 });
-    let res = net.train(data)
-
-    let net2 = new brain.NeuralNetwork({ momentum: 0.5 });
-    let res2 = net2.train(data)
-
-    assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
-  });
-});
-
-
-
-describe('async neural network options', () => {
-  it('learningRate ASYNC - higher learning rate should train faster', (done) => {
-    let data = [
-      { input: [0, 0], output: [0] },
-      { input: [0, 1], output: [1] },
-      { input: [1, 0], output: [1] },
-      { input: [1, 1], output: [1] }
-    ];
-
-    let net = new brain.NeuralNetwork();
-    let net2 = new brain.NeuralNetwork();
-
-    let p1 = net.trainAsync(data, { learningRate: 0.5 });
-    let p2 = net2.trainAsync(data, { learningRate: 0.8 });
-
-    Promise
-      .all([p1, p2])
-      .then(values => {
-        let res = values[0];
-        let res2 = values[1];
-        assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
-        done();
-      })
-      .catch(err => {
-        assert.ok(false, err.toString())
-      });
-  }).timeout(5000);
-
-  it('momentum ASYNC - higher momentum should train faster', (done) => {
-    let data = [
-      { input: [0, 0], output: [0] },
-      { input: [0, 1], output: [1] },
-      { input: [1, 0], output: [1] },
-      { input: [1, 1], output: [1] }
-    ];
-
-    let net = new brain.NeuralNetwork({ momentum: 0.1 });
-    let net2 = new brain.NeuralNetwork({ momentum: 0.5 });
-
-    let p1 = net.trainAsync(data);
-    let p2 = net2.trainAsync(data);
-
-    Promise.all([p1, p2])
-      .then(values => {
-        let res = values[0];
-        let res2 = values[1];
-        assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
-        done();
-      }).catch(err => {
-        assert.ok(false, err.toString())
-      });
-  }).timeout(5000);
 })
 
 
-describe('log', () => {
-  let logCalled = false;
-
-  beforeEach(() => { logCalled = false; });
-
-  function logFunction(str) {
-    logCalled = true;
-  }
-
-  function trainWithLog(log, expected) {
-    let net = new brain.NeuralNetwork();
-    net.train(
-      [ { input: [0], output: [0] } ],
-      { log: log, logPeriod: 1, iterations: 1 }
-    );
-    assert.equal(logCalled, expected)
-  }
-
-  function trainWithLogAsync(log, expected, done) {
-    let net = new brain.NeuralNetwork();
-    net
-      .trainAsync(
-        [ {input: [0], output: [0]} ],
-        { log: log, logPeriod: 1, iterations: 1 }
-      )
-      .then(res => {
-        assert.equal(logCalled, expected);
-        done();
-      })
-      .catch(err => {
-        assert.ok(false, err.toString())
-      });
-  }
-
-  it('should call log method', () => { trainWithLog(logFunction, true); });
-  it('should not call log method', () => { trainWithLog(false, false); });
-
-  it('ASYNC should call log method', done => { trainWithLogAsync(logFunction, true, done); }).timeout(5000);
-  it('ASYNC should not call log method', done => { trainWithLogAsync(false, false, done); }).timeout(5000);
-});
+describe ('neural network constructor values', () => {
+  it('iterations should be settable in the constructor', () => {
+    let opts = { iterations: 5};
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.iterations, net.trainOpts.iterations, `iterations => ${net.trainOpts.iterations} but should be ${opts.iterations}`);
+  })
+
+  it('errorThresh should be settable in the constructor', () => {
+    let opts = { errorThresh: 0.1 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.errorThresh, net.trainOpts.errorThresh, `errorThresh => ${net.trainOpts.errorThresh} but should be ${opts.errorThresh}`);
+  })
+
+  it('log should allow setting the training options to the constructor', () => {
+    let log = function (res) {};
+    let opts = { log: log };
+    var net = new brain.NeuralNetwork(opts);
+    assert.ok(typeof net.trainOpts.log  === 'function', `log => ${net.trainOpts.log} but should be ${opts.log}`);
+  })
+
+  it('logPeriod should be settable in the constructor', () => {
+    let opts = { logPeriod: 5 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.logPeriod, net.trainOpts.logPeriod, `logPeriod => ${net.trainOpts.logPeriod} but should be ${opts.logPeriod}`);
+  })
+
+  it('learningRate should be settable in the constructor', () => {
+    let opts = { learningRate: 0.5 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.learningRate, net.trainOpts.learningRate, `learningRate => ${net.trainOpts.learningRate} but should be ${opts.learningRate}`);
+  })
+
+  it('momentum should be settable in the constructor', () => {
+    let opts = { momentum: 0.2 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.momentum, net.trainOpts.momentum, `momentum => ${net.trainOpts.momentum} but should be ${opts.momentum}`);
+  })
+
+  it('callback should be settable in the constructor', () => {
+    let cb = function (res) {};
+    let opts = { callback: cb };
+    var net = new brain.NeuralNetwork(opts);
+    assert.ok(typeof net.trainOpts.callback  === 'function', `callback => ${net.trainOpts.callback} but should be ${opts.callback}`);
+  })
+
+  it('callbackPeriod should be settable in the constructor', () => {
+    let opts = { callbackPeriod: 2 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.callbackPeriod, net.trainOpts.callbackPeriod, `callbackPeriod => ${net.trainOpts.callbackPeriod} but should be ${opts.callbackPeriod}`);
+  })
+
+  it('timeout should be settable in the constructor', () => {
+    let opts = { timeout: 1500 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.timeout, net.trainOpts.timeout, `timeout => ${net.trainOpts.timeout} but should be ${opts.timeout}`);
+  })
+
+  it('binaryThresh should be settable in the constructor', () => {
+    let opts = { binaryThresh: 0.2 };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.binaryThresh, net.binaryThresh, `binaryThresh => ${net.binaryThresh} but should be ${opts.binaryThresh}`);
+  })
+
+  it('hiddenLayers should be settable in the constructor', () => {
+    let opts = { hiddenLayers: [2, 3, 4] };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(JSON.stringify(opts.hiddenLayers), JSON.stringify(net.hiddenLayers), `hiddenLayers => ${net.hiddenLayers} but should be ${opts.hiddenLayers}`);
+  })
+
+  it('activation should be settable in the constructor', () => {
+    let opts = { activation: 'relu' };
+    var net = new brain.NeuralNetwork(opts);
+    assert.equal(opts.activation, net.activation, `activation => ${net.activation} but should be ${opts.activation}`);
+  })
+});
\ No newline at end of file
diff --git a/test/base/trainopts.js b/test/base/trainopts.js
index 31d18769d..e9baa0b75 100644
--- a/test/base/trainopts.js
+++ b/test/base/trainopts.js
@@ -6,20 +6,20 @@ let data = [{input: [0, 0], output: [0]},
             {input: [1, 0], output: [1]},
             {input: [1, 1], output: [1]}];
 
-describe('train() options', function () {
-  it('train until error threshold reached', function () {
+describe('train() options', () => {
+  it('train until error threshold reached', () => {
     let net = new brain.NeuralNetwork();
-    var res = net.train (data, { errorThresh: 0.2 });
+    let res = net.train(data, { errorThresh: 0.2 });
     assert.ok(res.error < 0.2, `[res.error, ${res.error}] should have been less then 0.2`);
   });
 
-  it('train until max iterations reached', function () {
+  it('train until max iterations reached', () => {
     let net = new brain.NeuralNetwork();
-    var res = net.train(data, { iterations: 25 });
+    let res = net.train(data, { iterations: 25 });
     assert.equal(res.iterations, 25, `[res.iterations, ${res.iterations}] should have been less then 25`);
   });
 
-  it('training callback called with training stats', function () {
+  it('training callback called with training stats', () => {
     let iters = 100;
     let period = 20;
     let target = iters / period;
@@ -37,4 +37,139 @@ describe('train() options', function () {
     });
     assert.ok(target === calls, `[calls, ${calls}] should be the same as [target, ${target}]`);
   });
+
+  it('learningRate - higher learning rate should train faster', () => {
+    let data = [
+      { input: [0, 0], output: [0] },
+      { input: [0, 1], output: [1] },
+      { input: [1, 0], output: [1] },
+      { input: [1, 1], output: [1] }
+    ];
+
+    let net = new brain.NeuralNetwork();
+    let res = net.train(data, { learningRate: 0.5 });
+
+    let net2 = new brain.NeuralNetwork();
+    let res2 = net2.train(data, { learningRate: 0.8 });
+
+    assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} should be greater than ${res2.iterations * 1.1}`);
+  });
+
+
+  it('momentum - higher momentum should train faster', () => {
+    let data = [
+      { input: [0, 0], output: [0] },
+      { input: [0, 1], output: [1] },
+      { input: [1, 0], output: [1] },
+      { input: [1, 1], output: [1] }
+    ];
+
+    let net = new brain.NeuralNetwork({ momentum: 0.1 });
+    let res = net.train(data)
+
+    let net2 = new brain.NeuralNetwork({ momentum: 0.5 });
+    let res2 = net2.train(data)
+
+    assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
+  });
+});
+
+
+describe('async train() options', () => {
+  it('train until error threshold reached', (done) => {
+    let net = new brain.NeuralNetwork();
+    let p1 = net
+      .trainAsync(data, { errorThresh: 0.2 })
+      .then (res => {
+        assert.ok(res.error < 0.2, `[res.error, ${res.error}] should have been less then 0.2`);
+        done();
+      })
+      .catch(err => { assert.ok(false, err.toString()) });
+  });
+
+  it('train until max iterations reached', (done) => {
+    let net = new brain.NeuralNetwork();
+    let res = net
+      .trainAsync(data, { iterations: 25 })
+      .then(res => {
+        assert.equal(res.iterations, 25, `[res.iterations, ${res.iterations}] should have been less then 25`);
+        done();
+      })
+      .catch(err => { assert.ok(false, err.toString()) });
+  });
+
+  it('asyinc training callback called with training stats', (done) => {
+    let iters = 100;
+    let period = 20;
+    let target = iters / period;
+
+    let calls = 0;
+
+    let net = new brain.NeuralNetwork();
+    net.trainAsync(data, {
+      iterations: iters,
+      callbackPeriod: period,
+      callback: (res) => {
+        assert.ok(res.iterations % period == 0);
+        calls++;
+      }
+    })
+    .then (res => {
+      assert.ok(target === calls, `[calls, ${calls}] should be the same as [target, ${target}]`);
+      done();
+    })
+    .catch(err => { assert.ok(false, err.toString()) });
+  });
+
+  it('learningRate ASYNC - higher learning rate should train faster', (done) => {
+    let data = [
+      { input: [0, 0], output: [0] },
+      { input: [0, 1], output: [1] },
+      { input: [1, 0], output: [1] },
+      { input: [1, 1], output: [1] }
+    ];
+
+    let net = new brain.NeuralNetwork();
+    let net2 = new brain.NeuralNetwork();
+
+    let p1 = net.trainAsync(data, { learningRate: 0.5 });
+    let p2 = net2.trainAsync(data, { learningRate: 0.8 });
+
+    Promise
+      .all([p1, p2])
+      .then(values => {
+        let res = values[0];
+        let res2 = values[1];
+        assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
+        done();
+      })
+      .catch(err => {
+        assert.ok(false, err.toString())
+      });
+  }).timeout(5000);
+
+  it('momentum ASYNC - higher momentum should train faster', (done) => {
+    let data = [
+      { input: [0, 0], output: [0] },
+      { input: [0, 1], output: [1] },
+      { input: [1, 0], output: [1] },
+      { input: [1, 1], output: [1] }
+    ];
+
+    let net = new brain.NeuralNetwork({ momentum: 0.1 });
+    let net2 = new brain.NeuralNetwork({ momentum: 0.5 });
+
+    let p1 = net.trainAsync(data);
+    let p2 = net2.trainAsync(data);
+
+    Promise.all([p1, p2])
+      .then(values => {
+        let res = values[0];
+        let res2 = values[1];
+        assert.ok(res.iterations > (res2.iterations * 1.1), `${res.iterations} !> ${res2.iterations * 1.1}`);
+        done();
+      }).catch(err => {
+        assert.ok(false, err.toString())
+      });
+  }).timeout(5000);
 });

From 27755d73eec236c56b985f2be1dca553d251e574 Mon Sep 17 00:00:00 2001
From: Fred Christensen <fred@ifit.com>
Date: Sat, 27 Jan 2018 22:29:06 -0700
Subject: [PATCH 3/5] Updating some things

---
 README.md                  |     2 +
 browser.js                 | 23090 ++++++++++++++++++-----------------
 browser.min.js             |   123 +-
 dist/neural-network.js     |   271 +-
 dist/neural-network.js.map |     2 +-
 test/base/json.js          |    19 +
 6 files changed, 11864 insertions(+), 11643 deletions(-)

diff --git a/README.md b/README.md
index 6a5bab927..a8346a1eb 100644
--- a/README.md
+++ b/README.md
@@ -149,6 +149,8 @@ The learning rate is a parameter that influences how quickly the network trains.
 
 The momentum is similar to learning rate, expecting a value from `0` to `1` as well but it is multiplied against the next level's change value.  The default value is `0.1`
 
+Any of these training options can be passed into the constructor or passed into the `updateTrainingOptions(opts)` method and they will be saved on the network and used any time you trian.  If you save your network to json, these training options are saved and restored as well (except for callback and if the log is set restored log will be console.log).
+
 ### Async Training
 `trainAsync()` takes the same arguments as train (data and options).  Instead of returning the results object from training it returns a promise that when resolved will return the training results object.
 
diff --git a/browser.js b/browser.js
index 020b8f248..29bf945cd 100644
--- a/browser.js
+++ b/browser.js
@@ -11,6 +11,7 @@
  * acorn:
  *   license: MIT (http://opensource.org/licenses/MIT)
  *   maintainers: Marijn Haverbeke <marijnh@gmail.com>, Ingvar Stepanyan <me@rreverser.com>
+ *   contributors: List of Acorn contributors. Updated before every release., Adrian Heine, Adrian Heine né Lang, Adrian Rakovsky, Alistair Braidwood, Amila Welihinda, Andres Suarez, Angelo, Aparajita Fishman, Arian Stolwijk, Artem Govorov, Bradley Heinz, Brandon Mills, Charles Hughes, Charmander, Conrad Irwin, Daniel Tschinder, David Bonnet, Domenico Matteo, ehmicky, Felix Maier, Forbes Lindesay, Gilad Peleg, impinball, Ingvar Stepanyan, Jackson Ray Hamilton, Jesse McCarthy, Jiaxing Wang, Joel Kemp, Johannes Herr, John-David Dalton, Jordan Klassen, Jürg Lehni, Kai Cataldo, keeyipchan, Keheliya Gallaba, Kevin Irish, Kevin Kwok, krator, laosb, Marek, Marijn Haverbeke, Martin Carlberg, Mat Garcia, Mathias Bynens, Mathieu 'p01' Henri, Matthew Bastien, Max Schaefer, Max Zerzouri, Mihai Bazon, Mike Rennie, naoh, Nicholas C. Zakas, Nick Fitzgerald, Olivier Thomann, Oskar Schöldström, Paul Harper, Peter Rust, PlNG, Prayag Verma, ReadmeCritic, r-e-d, Richard Gibson, Rich Harris, Sebastian McKenzie, Shahar Soel, Simen Bekkhus, Teddy Katz, Timothy Gu, Toru Nagashima, Victor Homyakov, Wexpo Lyu, zsjforcn
  *   homepage: https://github.com/acornjs/acorn
  *   version: 5.3.0
  *
@@ -29,12 +30,14 @@
  *
  * core-util-is:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)
+ *   author: Isaac Z. Schlueter <i@izs.me>
+ *   homepage: https://github.com/isaacs/core-util-is#readme
  *   version: 1.0.2
  *
  * events:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)
+ *   author: Irakli Gozalishvili <rfobic@gmail.com>
+ *   homepage: https://github.com/Gozala/events#readme
  *   version: 1.1.1
  *
  * gpu.js:
@@ -47,10 +50,12 @@
  *   license: BSD-3-Clause (http://opensource.org/licenses/BSD-3-Clause)
  *   author: Feross Aboukhadijeh <feross@feross.org>
  *   contributors: Romain Beauxis <toots@rastageeks.org>
+ *   homepage: https://github.com/feross/ieee754#readme
  *   version: 1.1.8
  *
  * inherits:
  *   license: ISC (http://opensource.org/licenses/ISC)
+ *   homepage: https://github.com/isaacs/inherits#readme
  *   version: 2.0.3
  *
  * isarray:
@@ -62,6 +67,7 @@
  * process:
  *   license: MIT (http://opensource.org/licenses/MIT)
  *   author: Roman Shtylman <shtylman@gmail.com>
+ *   homepage: https://github.com/shtylman/node-process#readme
  *   version: 0.11.10
  *
  * process-nextick-args:
@@ -71,6 +77,7 @@
  *
  * readable-stream:
  *   license: MIT (http://opensource.org/licenses/MIT)
+ *   homepage: https://github.com/nodejs/readable-stream#readme
  *   version: 2.3.3
  *
  * safe-buffer:
@@ -98,7 +105,7 @@
  *
  * util-deprecate:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)
+ *   author: Nathan Rajlich <nathan@tootallnate.net>
  *   homepage: https://github.com/TooTallNate/util-deprecate
  *   version: 1.0.2
  *
@@ -840,7 +847,7 @@ function mse(errors) {
   return sum / this.constants.size;
 }
 
-},{"./lookup":3,"./neural-network":5,"gpu.js":75}],5:[function(require,module,exports){
+},{"./lookup":3,"./neural-network":5,"gpu.js":76}],5:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -900,24 +907,24 @@ var NeuralNetwork = function () {
     key: 'trainDefaults',
     get: function get() {
       return {
-        iterations: 20000,
-        errorThresh: 0.005,
-        log: false,
-        logPeriod: 10,
-        learningRate: 0.3,
-        callback: null,
-        callbackPeriod: 10
+        iterations: 20000, // the maximum times to iterate the training data
+        errorThresh: 0.005, // the acceptable error percentage from training data
+        log: false, // true to use console.log, when a function is supplied it is used
+        logPeriod: 10, // iterations between logging out
+        learningRate: 0.3, // multiply's against the input and the delta then adds to momentum
+        momentum: 0.1, // multiply's against the specified "change" then adds to learning rate for change
+        callback: null, // a periodic call back that can be triggered while training
+        callbackPeriod: 10, // the number of iterations through the training data between callback calls
+        timeout: Infinity // the max number of milliseconds to train for
       };
     }
   }, {
     key: 'defaults',
     get: function get() {
       return {
-        learningRate: 0.3,
-        momentum: 0.1,
-        binaryThresh: 0.5,
-        hiddenLayers: null,
-        activation: 'sigmoid'
+        binaryThresh: 0.5, // ¯\_(ツ)_/¯
+        hiddenLayers: [3], // array of ints for the sizes of the hidden layers in the network
+        activation: 'sigmoid' // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']
       };
     }
   }]);
@@ -929,6 +936,8 @@ var NeuralNetwork = function () {
 
     Object.assign(this, this.constructor.defaults, options);
     this.hiddenSizes = options.hiddenLayers;
+    this.trainOpts = {};
+    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));
 
     this.sizes = null;
     this.outputLayer = null;
@@ -951,14 +960,15 @@ var NeuralNetwork = function () {
 
   /**
    *
-   * @param {Number[]} sizes
+   * Expects this.sizes to have been set
    */
 
 
   _createClass(NeuralNetwork, [{
-    key: 'initialize',
-    value: function initialize(sizes) {
-      this.sizes = sizes;
+    key: '_initialize',
+    value: function _initialize() {
+      if (!this.sizes) throw new Error('Sizes must be set before initializing');
+
       this.outputLayer = this.sizes.length - 1;
       this.biases = []; // weights for bias nodes
       this.weights = [];
@@ -990,9 +1000,16 @@ var NeuralNetwork = function () {
 
       this.setActivation();
     }
+
+    /**
+     *
+     * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+     */
+
   }, {
     key: 'setActivation',
-    value: function setActivation() {
+    value: function setActivation(activation) {
+      this.activation = activation ? activation : this.activation;
       switch (this.activation) {
         case 'sigmoid':
           this.runInput = this.runInput || this.runInputSigmoid;
@@ -1137,27 +1154,114 @@ var NeuralNetwork = function () {
     /**
      *
      * @param data
-     * @returns sizes
+     * Verifies network sizes are initilaized
+     * If they are not it will initialize them based off the data set.
      */
 
   }, {
-    key: '_getSizesFromData',
-    value: function _getSizesFromData(data) {
-      var sizes = [];
-      var inputSize = data[0].input.length;
-      var outputSize = data[0].output.length;
-      var hiddenSizes = this.hiddenSizes;
-      if (!hiddenSizes) {
-        sizes.push(Math.max(3, Math.floor(inputSize / 2)));
+    key: '_verifyIsInitialized',
+    value: function _verifyIsInitialized(data) {
+      var _this = this;
+
+      if (this.sizes) return;
+
+      this.sizes = [];
+      this.sizes.push(data[0].input.length);
+      if (!this.hiddenSizes) {
+        this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));
       } else {
-        hiddenSizes.forEach(function (size) {
-          sizes.push(size);
+        this.hiddenSizes.forEach(function (size) {
+          _this.sizes.push(size);
         });
       }
+      this.sizes.push(data[0].output.length);
+
+      this._initialize();
+    }
+
+    /**
+     *
+     * @param options
+     *    Supports all `trainDefaults` properties
+     *    also supports:
+     *       learningRate: (number),
+     *       momentum: (number),
+     *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+     */
+
+  }, {
+    key: 'updateTrainingOptions',
+    value: function updateTrainingOptions(opts) {
+      if (opts.iterations) {
+        this.trainOpts.iterations = opts.iterations;
+      }
+      if (opts.errorThresh) {
+        this.trainOpts.errorThresh = opts.errorThresh;
+      }
+      if (opts.log) {
+        this._setLogMethod(opts.log);
+      }
+      if (opts.logPeriod) {
+        this.trainOpts.logPeriod = opts.logPeriod;
+      }
+      if (opts.learningRate) {
+        this.trainOpts.learningRate = opts.learningRate;
+      }
+      if (opts.momentum) {
+        this.trainOpts.momentum = opts.momentum;
+      }
+      if (opts.callback) {
+        this.trainOpts.callback = opts.callback;
+      }
+      if (opts.callbackPeriod) {
+        this.trainOpts.callbackPeriod = opts.callbackPeriod;
+      }
+      if (opts.timeout) {
+        this.trainOpts.timeout = opts.timeout;
+      }
+      if (opts.activation) {
+        this.activation = opts.activation;
+      }
+    }
+
+    /**
+     *
+     *  Gets JSON of trainOpts object
+     *    NOTE: Activation is stored directly on JSON object and not in the training options
+     */
 
-      sizes.unshift(inputSize);
-      sizes.push(outputSize);
-      return sizes;
+  }, {
+    key: '_getTrainOptsJSON',
+    value: function _getTrainOptsJSON() {
+      var results = {};
+      if (this.trainOpts.iterations) {
+        results.iterations = this.trainOpts.iterations;
+      }
+      if (this.trainOpts.errorThresh) {
+        results.errorThresh = this.trainOpts.errorThresh;
+      }
+      if (this.trainOpts.logPeriod) {
+        results.logPeriod = this.trainOpts.logPeriod;
+      }
+      if (this.trainOpts.learningRate) {
+        results.learningRate = this.trainOpts.learningRate;
+      }
+      if (this.trainOpts.momentum) {
+        results.momentum = this.trainOpts.momentum;
+      }
+      if (this.trainOpts.callback) {
+        results.callback = this.trainOpts.callback;
+      }
+      if (this.trainOpts.callbackPeriod) {
+        results.callbackPeriod = this.trainOpts.callbackPeriod;
+      }
+      if (this.trainOpts.timeout) {
+        results.timeout = this.trainOpts.timeout;
+      }
+      if (this.trainOpts.log) {
+        results.log = true;
+      }
+      return results;
     }
 
     /**
@@ -1171,8 +1275,13 @@ var NeuralNetwork = function () {
   }, {
     key: '_setLogMethod',
     value: function _setLogMethod(log) {
-      if (log) return console.log;
-      return false;
+      if (typeof log === 'function') {
+        this.trainOpts.log = log;
+      } else if (log) {
+        this.trainOpts.log = console.log;
+      } else {
+        this.trainOpts.log = false;
+      }
     }
 
     /**
@@ -1184,10 +1293,10 @@ var NeuralNetwork = function () {
 
   }, {
     key: '_calculateTrainingError',
-    value: function _calculateTrainingError(data, learningRate) {
+    value: function _calculateTrainingError(data) {
       var sum = 0;
       for (var i = 0; i < data.length; ++i) {
-        sum += this.trainPattern(data[i].input, data[i].output, learningRate);
+        sum += this._trainPattern(data[i].input, data[i].output);
       }
       return sum / data.length;
     }
@@ -1199,48 +1308,45 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: '_checkTrainingTick',
-    value: function _checkTrainingTick(data, status, options) {
+    key: '_trainingTick',
+    value: function _trainingTick(data, status) {
       status.iterations++;
-      status.error = this._calculateTrainingError(data, options.learningRate);
+      status.error = this._calculateTrainingError(data);
 
-      if (options.log && status.iterations % options.logPeriod === 0) {
-        options.log('iterations: ' + status.iterations + ', training error: ' + status.error);
+      if (this.trainOpts.log && status.iterations % this.trainOpts.logPeriod === 0) {
+        this.trainOpts.log('iterations: ' + status.iterations + ', training error: ' + status.error);
       }
 
-      if (options.callback && status.iterations % options.callbackPeriod === 0) {
-        options.callback(Object.assign(status));
+      if (this.trainOpts.callback && status.iterations % this.trainOpts.callbackPeriod === 0) {
+        this.trainOpts.callback(Object.assign(status));
       }
     }
 
     /**
      *
      * @param data
-     * @param _options
+     * @param options
      * @returns {{error: number, iterations: number}}
      */
 
   }, {
     key: 'train',
     value: function train(data) {
-      var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-      var options = Object.assign({}, this.constructor.trainDefaults, _options);
+      this.updateTrainingOptions(options);
       data = this.formatData(data);
-      options.log = this._setLogMethod(options.log);
-      options.learningRate = _options.learningRate || this.learningRate || options.learningRate;
+      var endTime = Date.now() + this.trainOpts.timeout;
+
       var status = {
         error: 1,
         iterations: 0
       };
 
-      if (this.sizes === null) {
-        var sizes = this._getSizesFromData(data);
-        this.initialize(sizes);
-      }
+      this._verifyIsInitialized(data);
 
-      while (status.iterations < options.iterations && status.error > options.errorThresh) {
-        this._checkTrainingTick(data, status, options);
+      while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {
+        this._trainingTick(data, status);
       }
 
       return status;
@@ -1249,7 +1355,7 @@ var NeuralNetwork = function () {
     /**
      *
      * @param data
-     * @param _options
+     * @param options
      * @param cb
      * @returns {{error: number, iterations: number}}
      */
@@ -1257,34 +1363,28 @@ var NeuralNetwork = function () {
   }, {
     key: 'trainAsync',
     value: function trainAsync(data) {
-      var _this = this;
+      var _this2 = this;
 
-      var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       return new Promise(function (resolve, reject) {
-        var options = Object.assign({}, _this.constructor.trainDefaults, _options);
-        data = _this.formatData(data);
-        options.log = _this._setLogMethod(options.log);
-        options.learningRate = _options.learningRate || _this.learningRate || options.learningRate;
-        var endTime = Date.now() + options.trainTimeMs;
+        _this2.updateTrainingOptions(options);
+        data = _this2.formatData(data);
+        var endTime = Date.now() + _this2.trainOpts.timeout;
 
         var status = {
           error: 1,
           iterations: 0
         };
 
-        if (_this.sizes === null) {
-          var sizes = _this._getSizesFromData(data);
-          _this.initialize(sizes);
-        }
+        _this2._verifyIsInitialized(data);
 
-        var items = new Array(options.iterations);
+        var items = new Array(_this2.trainOpts.iterations);
         var thaw = new _thaw2.default(items, {
           delay: true,
           each: function each() {
-            _this._checkTrainingTick(data, status, options);
-
-            if (status.error < options.errorThresh) {
+            _this2._trainingTick(data, status);
+            if (status.error < _this2.trainOpts.errorThresh || Date.now() > endTime) {
               thaw.stop();
             }
           },
@@ -1301,20 +1401,18 @@ var NeuralNetwork = function () {
      *
      * @param input
      * @param target
-     * @param learningRate
      */
 
   }, {
-    key: 'trainPattern',
-    value: function trainPattern(input, target, learningRate) {
-      learningRate = learningRate || this.learningRate;
+    key: '_trainPattern',
+    value: function _trainPattern(input, target) {
 
       // forward propagate
       this.runInput(input);
 
       // back propagate
       this.calculateDeltas(target);
-      this.adjustWeights(learningRate);
+      this.adjustWeights();
 
       var error = (0, _mse2.default)(this.errors[this.outputLayer]);
       return error;
@@ -1430,12 +1528,12 @@ var NeuralNetwork = function () {
 
     /**
      *
-     * @param learningRate
+     * Changes weights of networks
      */
 
   }, {
     key: 'adjustWeights',
-    value: function adjustWeights(learningRate) {
+    value: function adjustWeights() {
       for (var layer = 1; layer <= this.outputLayer; layer++) {
         var incoming = this.outputs[layer - 1];
 
@@ -1445,12 +1543,12 @@ var NeuralNetwork = function () {
           for (var k = 0; k < incoming.length; k++) {
             var change = this.changes[layer][node][k];
 
-            change = learningRate * delta * incoming[k] + this.momentum * change;
+            change = this.trainOpts.learningRate * delta * incoming[k] + this.trainOpts.momentum * change;
 
             this.changes[layer][node][k] = change;
             this.weights[layer][node][k] += change;
           }
-          this.biases[layer][node] += learningRate * delta;
+          this.biases[layer][node] += this.trainOpts.learningRate * delta;
         }
       }
     }
@@ -1464,7 +1562,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'formatData',
     value: function formatData(data) {
-      var _this2 = this;
+      var _this3 = this;
 
       if (!Array.isArray(data)) {
         // turn stream datum into array
@@ -1481,7 +1579,7 @@ var NeuralNetwork = function () {
           }));
         }
         data = data.map(function (datum) {
-          var array = _lookup2.default.toArray(_this2.inputLookup, datum.input);
+          var array = _lookup2.default.toArray(_this3.inputLookup, datum.input);
           return Object.assign({}, datum, { input: array });
         }, this);
       }
@@ -1493,7 +1591,7 @@ var NeuralNetwork = function () {
           }));
         }
         data = data.map(function (datum) {
-          var array = _lookup2.default.toArray(_this2.outputLookup, datum.output);
+          var array = _lookup2.default.toArray(_this3.outputLookup, datum.output);
           return Object.assign({}, datum, { output: array });
         }, this);
       }
@@ -1514,7 +1612,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'test',
     value: function test(data) {
-      var _this3 = this;
+      var _this4 = this;
 
       data = this.formatData(data);
 
@@ -1533,13 +1631,13 @@ var NeuralNetwork = function () {
       var sum = 0;
 
       var _loop = function _loop(i) {
-        var output = _this3.runInput(data[i].input);
+        var output = _this4.runInput(data[i].input);
         var target = data[i].output;
 
         var actual = void 0,
             expected = void 0;
         if (isBinary) {
-          actual = output[0] > _this3.binaryThresh ? 1 : 0;
+          actual = output[0] > _this4.binaryThresh ? 1 : 0;
           expected = target[0];
         } else {
           actual = output.indexOf((0, _max2.default)(output));
@@ -1674,7 +1772,8 @@ var NeuralNetwork = function () {
         layers: layers,
         outputLookup: !!this.outputLookup,
         inputLookup: !!this.inputLookup,
-        activation: this.activation
+        activation: this.activation,
+        trainOpts: this._getTrainOptsJSON()
       };
     }
 
@@ -1687,7 +1786,8 @@ var NeuralNetwork = function () {
   }, {
     key: 'fromJSON',
     value: function fromJSON(json) {
-      this.initialize(json.sizes);
+      this.sizes = json.sizes;
+      this._initialize();
 
       for (var i = 0; i <= this.outputLayer; i++) {
         var layer = json.layers[i];
@@ -1706,7 +1806,7 @@ var NeuralNetwork = function () {
           }
         }
       }
-
+      this.updateTrainingOptions(json.trainOpts);
       this.setActivation();
       return this;
     }
@@ -1784,7 +1884,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'isRunnable',
     get: function get() {
-      var _this4 = this;
+      var _this5 = this;
 
       if (!this.runInput) {
         console.error('Activation function has not been initialized, did you run train()?');
@@ -1792,7 +1892,7 @@ var NeuralNetwork = function () {
       }
 
       var checkFns = ['sizes', 'outputLayer', 'biases', 'weights', 'outputs', 'deltas', 'changes', 'errors'].filter(function (c) {
-        return _this4[c] === null;
+        return _this5[c] === null;
       });
 
       if (checkFns.length > 0) {
@@ -4201,7 +4301,7 @@ function uniques(arr) {
   return [].concat(_toConsumableArray(new Set(arr)));
 }
 
-},{"./lookup":3,"stream":98}],34:[function(require,module,exports){
+},{"./lookup":3,"stream":97}],34:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -4654,7864 +4754,7272 @@ if (typeof window !== 'undefined') {
   module.exports = brain;
 }
 },{"./dist/cross-validate":1,"./dist/likely":2,"./dist/lookup":3,"./dist/neural-network":5,"./dist/neural-network-gpu":4,"./dist/recurrent/gru":6,"./dist/recurrent/lstm":7,"./dist/recurrent/rnn":32,"./dist/train-stream":33,"./dist/utilities/data-formatter":34,"./dist/utilities/max":35,"./dist/utilities/mse":36,"./dist/utilities/ones":37,"./dist/utilities/random":39,"./dist/utilities/random-weight":38,"./dist/utilities/randos":40,"./dist/utilities/range":41,"./dist/utilities/to-array":42,"./dist/utilities/zeros":43}],45:[function(require,module,exports){
-'use strict'
-
-exports.byteLength = byteLength
-exports.toByteArray = toByteArray
-exports.fromByteArray = fromByteArray
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(factory((global.acorn = {})));
+}(this, (function (exports) { 'use strict';
 
-var lookup = []
-var revLookup = []
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+// Reserved word lists for various dialects of the language
 
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-for (var i = 0, len = code.length; i < len; ++i) {
-  lookup[i] = code[i]
-  revLookup[code.charCodeAt(i)] = i
-}
+var reservedWords = {
+  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+  5: "class enum extends super const export import",
+  6: "enum",
+  strict: "implements interface let package private protected public static yield",
+  strictBind: "eval arguments"
+};
 
-revLookup['-'.charCodeAt(0)] = 62
-revLookup['_'.charCodeAt(0)] = 63
+// And the keywords
 
-function placeHoldersCount (b64) {
-  var len = b64.length
-  if (len % 4 > 0) {
-    throw new Error('Invalid string. Length must be a multiple of 4')
-  }
+var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
 
-  // the number of equal signs (place holders)
-  // if there are two placeholders, than the two characters before it
-  // represent one byte
-  // if there is only one, then the three characters before it represent 2 bytes
-  // this is just a cheap hack to not do indexOf twice
-  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
-}
+var keywords = {
+  5: ecma5AndLessKeywords,
+  6: ecma5AndLessKeywords + " const class extends export import super"
+};
 
-function byteLength (b64) {
-  // base64 is 4/3 + up to two characters of the original data
-  return (b64.length * 3 / 4) - placeHoldersCount(b64)
-}
+var keywordRelationalOperator = /^in(stanceof)?$/;
 
-function toByteArray (b64) {
-  var i, l, tmp, placeHolders, arr
-  var len = b64.length
-  placeHolders = placeHoldersCount(b64)
+// ## Character categories
 
-  arr = new Arr((len * 3 / 4) - placeHolders)
+// Big ugly regular expressions that match characters in the
+// whitespace, identifier, and identifier-start categories. These
+// are only applied when a character is found to actually have a
+// code point above 128.
+// Generated by `bin/generate-identifier-regex.js`.
 
-  // if there are placeholders, only get up to the last complete 4 chars
-  l = placeHolders > 0 ? len - 4 : len
+var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fd5\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ae\ua7b0-\ua7b7\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab65\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d4-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d01-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf8\u1cf9\u1dc0-\u1df5\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
 
-  var L = 0
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
 
-  for (i = 0; i < l; i += 4) {
-    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
-    arr[L++] = (tmp >> 16) & 0xFF
-    arr[L++] = (tmp >> 8) & 0xFF
-    arr[L++] = tmp & 0xFF
-  }
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
 
-  if (placeHolders === 2) {
-    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
-    arr[L++] = tmp & 0xFF
-  } else if (placeHolders === 1) {
-    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
-    arr[L++] = (tmp >> 8) & 0xFF
-    arr[L++] = tmp & 0xFF
-  }
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by bin/generate-identifier-regex.js
 
-  return arr
-}
+// eslint-disable-next-line comma-spacing
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541];
 
-function tripletToBase64 (num) {
-  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
-}
+// eslint-disable-next-line comma-spacing
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239];
 
-function encodeChunk (uint8, start, end) {
-  var tmp
-  var output = []
-  for (var i = start; i < end; i += 3) {
-    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
-    output.push(tripletToBase64(tmp))
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+  var pos = 0x10000;
+  for (var i = 0; i < set.length; i += 2) {
+    pos += set[i];
+    if (pos > code) { return false }
+    pos += set[i + 1];
+    if (pos >= code) { return true }
   }
-  return output.join('')
 }
 
-function fromByteArray (uint8) {
-  var tmp
-  var len = uint8.length
-  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
-  var output = ''
-  var parts = []
-  var maxChunkLength = 16383 // must be multiple of 3
-
-  // go through the array every three bytes, we'll deal with trailing stuff later
-  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
-  }
+// Test whether a given character code starts an identifier.
 
-  // pad the end with zeros, but make sure to not forget the extra bytes
-  if (extraBytes === 1) {
-    tmp = uint8[len - 1]
-    output += lookup[tmp >> 2]
-    output += lookup[(tmp << 4) & 0x3F]
-    output += '=='
-  } else if (extraBytes === 2) {
-    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
-    output += lookup[tmp >> 10]
-    output += lookup[(tmp >> 4) & 0x3F]
-    output += lookup[(tmp << 2) & 0x3F]
-    output += '='
-  }
+function isIdentifierStart(code, astral) {
+  if (code < 65) { return code === 36 }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes)
+}
 
-  parts.push(output)
+// Test whether a given character is part of an identifier.
 
-  return parts.join('')
+function isIdentifierChar(code, astral) {
+  if (code < 48) { return code === 36 }
+  if (code < 58) { return true }
+  if (code < 65) { return false }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
 }
 
-},{}],46:[function(require,module,exports){
+// ## Token types
 
-},{}],47:[function(require,module,exports){
-(function (global){
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
- * @license  MIT
- */
-/* eslint-disable no-proto */
+// The assignment of fine-grained, information-carrying type objects
+// allows the tokenizer to store the information it has about a
+// token in a way that is very cheap for the parser to look up.
 
-'use strict'
+// All token type variables start with an underscore, to make them
+// easy to recognize.
 
-var base64 = require('base64-js')
-var ieee754 = require('ieee754')
-var isArray = require('isarray')
+// The `beforeExpr` property is used to disambiguate between regular
+// expressions and divisions. It is set on all token types that can
+// be followed by an expression (thus, a slash after them would be a
+// regular expression).
+//
+// The `startsExpr` property is used to check if the token ends a
+// `yield` expression. It is set on all token types that either can
+// directly start an expression (like a quotation mark) or can
+// continue an expression (like the body of a string).
+//
+// `isLoop` marks a keyword as starting a loop, which is important
+// to know when parsing a label, in order to allow or disallow
+// continue jumps to that label.
 
-exports.Buffer = Buffer
-exports.SlowBuffer = SlowBuffer
-exports.INSPECT_MAX_BYTES = 50
+var TokenType = function TokenType(label, conf) {
+  if ( conf === void 0 ) conf = {};
 
-/**
- * If `Buffer.TYPED_ARRAY_SUPPORT`:
- *   === true    Use Uint8Array implementation (fastest)
- *   === false   Use Object implementation (most compatible, even IE6)
- *
- * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
- * Opera 11.6+, iOS 4.2+.
- *
- * Due to various browser bugs, sometimes the Object implementation will be used even
- * when the browser supports typed arrays.
- *
- * Note:
- *
- *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
- *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
- *
- *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
- *
- *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
- *     incorrect length in some situations.
+  this.label = label;
+  this.keyword = conf.keyword;
+  this.beforeExpr = !!conf.beforeExpr;
+  this.startsExpr = !!conf.startsExpr;
+  this.isLoop = !!conf.isLoop;
+  this.isAssign = !!conf.isAssign;
+  this.prefix = !!conf.prefix;
+  this.postfix = !!conf.postfix;
+  this.binop = conf.binop || null;
+  this.updateContext = null;
+};
 
- * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
- * get the Object implementation, which is slower but behaves correctly.
- */
-Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
-  ? global.TYPED_ARRAY_SUPPORT
-  : typedArraySupport()
+function binop(name, prec) {
+  return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+var beforeExpr = {beforeExpr: true};
+var startsExpr = {startsExpr: true};
 
-/*
- * Export kMaxLength after typed array support is determined.
- */
-exports.kMaxLength = kMaxLength()
+// Map keyword names to token types.
 
-function typedArraySupport () {
-  try {
-    var arr = new Uint8Array(1)
-    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
-    return arr.foo() === 42 && // typed array instances can be augmented
-        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
-        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
-  } catch (e) {
-    return false
-  }
-}
+var keywords$1 = {};
 
-function kMaxLength () {
-  return Buffer.TYPED_ARRAY_SUPPORT
-    ? 0x7fffffff
-    : 0x3fffffff
+// Succinct definitions of keyword token types
+function kw(name, options) {
+  if ( options === void 0 ) options = {};
+
+  options.keyword = name;
+  return keywords$1[name] = new TokenType(name, options)
 }
 
-function createBuffer (that, length) {
-  if (kMaxLength() < length) {
-    throw new RangeError('Invalid typed array length')
-  }
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    // Return an augmented `Uint8Array` instance, for best performance
-    that = new Uint8Array(length)
-    that.__proto__ = Buffer.prototype
-  } else {
-    // Fallback: Return an object instance of the Buffer class
-    if (that === null) {
-      that = new Buffer(length)
-    }
-    that.length = length
-  }
+var types = {
+  num: new TokenType("num", startsExpr),
+  regexp: new TokenType("regexp", startsExpr),
+  string: new TokenType("string", startsExpr),
+  name: new TokenType("name", startsExpr),
+  eof: new TokenType("eof"),
 
-  return that
-}
+  // Punctuation token types.
+  bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+  bracketR: new TokenType("]"),
+  braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+  braceR: new TokenType("}"),
+  parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+  parenR: new TokenType(")"),
+  comma: new TokenType(",", beforeExpr),
+  semi: new TokenType(";", beforeExpr),
+  colon: new TokenType(":", beforeExpr),
+  dot: new TokenType("."),
+  question: new TokenType("?", beforeExpr),
+  arrow: new TokenType("=>", beforeExpr),
+  template: new TokenType("template"),
+  invalidTemplate: new TokenType("invalidTemplate"),
+  ellipsis: new TokenType("...", beforeExpr),
+  backQuote: new TokenType("`", startsExpr),
+  dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
 
-/**
- * The Buffer constructor returns instances of `Uint8Array` that have their
- * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
- * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
- * and the `Uint8Array` methods. Square bracket notation works as expected -- it
- * returns a single octet.
- *
- * The `Uint8Array` prototype remains unmodified.
- */
+  // Operators. These carry several kinds of properties to help the
+  // parser use them properly (the presence of these properties is
+  // what categorizes them as operators).
+  //
+  // `binop`, when present, specifies that this operator is a binary
+  // operator, and will refer to its precedence.
+  //
+  // `prefix` and `postfix` mark the operator as a prefix or postfix
+  // unary operator.
+  //
+  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+  // binary operators with a very low precedence, that should result
+  // in AssignmentExpression nodes.
 
-function Buffer (arg, encodingOrOffset, length) {
-  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
-    return new Buffer(arg, encodingOrOffset, length)
-  }
+  eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+  assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+  incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+  prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
+  logicalOR: binop("||", 1),
+  logicalAND: binop("&&", 2),
+  bitwiseOR: binop("|", 3),
+  bitwiseXOR: binop("^", 4),
+  bitwiseAND: binop("&", 5),
+  equality: binop("==/!=/===/!==", 6),
+  relational: binop("</>/<=/>=", 7),
+  bitShift: binop("<</>>/>>>", 8),
+  plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+  modulo: binop("%", 10),
+  star: binop("*", 10),
+  slash: binop("/", 10),
+  starstar: new TokenType("**", {beforeExpr: true}),
 
-  // Common case.
-  if (typeof arg === 'number') {
-    if (typeof encodingOrOffset === 'string') {
-      throw new Error(
-        'If encoding is specified then the first argument must be a string'
-      )
-    }
-    return allocUnsafe(this, arg)
-  }
-  return from(this, arg, encodingOrOffset, length)
-}
+  // Keyword token types.
+  _break: kw("break"),
+  _case: kw("case", beforeExpr),
+  _catch: kw("catch"),
+  _continue: kw("continue"),
+  _debugger: kw("debugger"),
+  _default: kw("default", beforeExpr),
+  _do: kw("do", {isLoop: true, beforeExpr: true}),
+  _else: kw("else", beforeExpr),
+  _finally: kw("finally"),
+  _for: kw("for", {isLoop: true}),
+  _function: kw("function", startsExpr),
+  _if: kw("if"),
+  _return: kw("return", beforeExpr),
+  _switch: kw("switch"),
+  _throw: kw("throw", beforeExpr),
+  _try: kw("try"),
+  _var: kw("var"),
+  _const: kw("const"),
+  _while: kw("while", {isLoop: true}),
+  _with: kw("with"),
+  _new: kw("new", {beforeExpr: true, startsExpr: true}),
+  _this: kw("this", startsExpr),
+  _super: kw("super", startsExpr),
+  _class: kw("class", startsExpr),
+  _extends: kw("extends", beforeExpr),
+  _export: kw("export"),
+  _import: kw("import"),
+  _null: kw("null", startsExpr),
+  _true: kw("true", startsExpr),
+  _false: kw("false", startsExpr),
+  _in: kw("in", {beforeExpr: true, binop: 7}),
+  _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
+  _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
+};
 
-Buffer.poolSize = 8192 // not used by this implementation
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
 
-// TODO: Legacy, not needed anymore. Remove in next major version.
-Buffer._augment = function (arr) {
-  arr.__proto__ = Buffer.prototype
-  return arr
+var lineBreak = /\r\n?|\n|\u2028|\u2029/;
+var lineBreakG = new RegExp(lineBreak.source, "g");
+
+function isNewLine(code) {
+  return code === 10 || code === 13 || code === 0x2028 || code === 0x2029
 }
 
-function from (that, value, encodingOrOffset, length) {
-  if (typeof value === 'number') {
-    throw new TypeError('"value" argument must not be a number')
-  }
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
 
-  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
-    return fromArrayBuffer(that, value, encodingOrOffset, length)
-  }
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 
-  if (typeof value === 'string') {
-    return fromString(that, value, encodingOrOffset)
-  }
+var ref = Object.prototype;
+var hasOwnProperty = ref.hasOwnProperty;
+var toString = ref.toString;
 
-  return fromObject(that, value)
+// Checks if an object has a property.
+
+function has(obj, propName) {
+  return hasOwnProperty.call(obj, propName)
 }
 
-/**
- * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
- * if value is a number.
- * Buffer.from(str[, encoding])
- * Buffer.from(array)
- * Buffer.from(buffer)
- * Buffer.from(arrayBuffer[, byteOffset[, length]])
- **/
-Buffer.from = function (value, encodingOrOffset, length) {
-  return from(null, value, encodingOrOffset, length)
-}
+var isArray = Array.isArray || (function (obj) { return (
+  toString.call(obj) === "[object Array]"
+); });
 
-if (Buffer.TYPED_ARRAY_SUPPORT) {
-  Buffer.prototype.__proto__ = Uint8Array.prototype
-  Buffer.__proto__ = Uint8Array
-  if (typeof Symbol !== 'undefined' && Symbol.species &&
-      Buffer[Symbol.species] === Buffer) {
-    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
-    Object.defineProperty(Buffer, Symbol.species, {
-      value: null,
-      configurable: true
-    })
-  }
-}
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
 
-function assertSize (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('"size" argument must be a number')
-  } else if (size < 0) {
-    throw new RangeError('"size" argument must not be negative')
-  }
-}
+var Position = function Position(line, col) {
+  this.line = line;
+  this.column = col;
+};
 
-function alloc (that, size, fill, encoding) {
-  assertSize(size)
-  if (size <= 0) {
-    return createBuffer(that, size)
-  }
-  if (fill !== undefined) {
-    // Only pay attention to encoding if it's a string. This
-    // prevents accidentally sending in a number that would
-    // be interpretted as a start offset.
-    return typeof encoding === 'string'
-      ? createBuffer(that, size).fill(fill, encoding)
-      : createBuffer(that, size).fill(fill)
-  }
-  return createBuffer(that, size)
-}
+Position.prototype.offset = function offset (n) {
+  return new Position(this.line, this.column + n)
+};
 
-/**
- * Creates a new filled Buffer instance.
- * alloc(size[, fill[, encoding]])
- **/
-Buffer.alloc = function (size, fill, encoding) {
-  return alloc(null, size, fill, encoding)
-}
+var SourceLocation = function SourceLocation(p, start, end) {
+  this.start = start;
+  this.end = end;
+  if (p.sourceFile !== null) { this.source = p.sourceFile; }
+};
 
-function allocUnsafe (that, size) {
-  assertSize(size)
-  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
-  if (!Buffer.TYPED_ARRAY_SUPPORT) {
-    for (var i = 0; i < size; ++i) {
-      that[i] = 0
+// The `getLineInfo` function is mostly useful when the
+// `locations` option is off (for performance reasons) and you
+// want to find the line/column position for a given character
+// offset. `input` should be the code string that the offset refers
+// into.
+
+function getLineInfo(input, offset) {
+  for (var line = 1, cur = 0;;) {
+    lineBreakG.lastIndex = cur;
+    var match = lineBreakG.exec(input);
+    if (match && match.index < offset) {
+      ++line;
+      cur = match.index + match[0].length;
+    } else {
+      return new Position(line, offset - cur)
     }
   }
-  return that
 }
 
-/**
- * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
- * */
-Buffer.allocUnsafe = function (size) {
-  return allocUnsafe(null, size)
-}
-/**
- * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
- */
-Buffer.allocUnsafeSlow = function (size) {
-  return allocUnsafe(null, size)
-}
+// A second optional argument can be given to further configure
+// the parser process. These options are recognized:
 
-function fromString (that, string, encoding) {
-  if (typeof encoding !== 'string' || encoding === '') {
-    encoding = 'utf8'
-  }
+var defaultOptions = {
+  // `ecmaVersion` indicates the ECMAScript version to parse. Must
+  // be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support
+  // for strict mode, the set of reserved words, and support for
+  // new syntax features. The default is 7.
+  ecmaVersion: 7,
+  // `sourceType` indicates the mode the code should be parsed in.
+  // Can be either `"script"` or `"module"`. This influences global
+  // strict mode and parsing of `import` and `export` declarations.
+  sourceType: "script",
+  // `onInsertedSemicolon` can be a callback that will be called
+  // when a semicolon is automatically inserted. It will be passed
+  // th position of the comma as an offset, and if `locations` is
+  // enabled, it is given the location as a `{line, column}` object
+  // as second argument.
+  onInsertedSemicolon: null,
+  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+  // trailing commas.
+  onTrailingComma: null,
+  // By default, reserved words are only enforced if ecmaVersion >= 5.
+  // Set `allowReserved` to a boolean value to explicitly turn this on
+  // an off. When this option has the value "never", reserved words
+  // and keywords can also not be used as property names.
+  allowReserved: null,
+  // When enabled, a return at the top level is not considered an
+  // error.
+  allowReturnOutsideFunction: false,
+  // When enabled, import/export statements are not constrained to
+  // appearing at the top of the program.
+  allowImportExportEverywhere: false,
+  // When enabled, hashbang directive in the beginning of file
+  // is allowed and treated as a line comment.
+  allowHashBang: false,
+  // When `locations` is on, `loc` properties holding objects with
+  // `start` and `end` properties in `{line, column}` form (with
+  // line being 1-based and column 0-based) will be attached to the
+  // nodes.
+  locations: false,
+  // A function can be passed as `onToken` option, which will
+  // cause Acorn to call that function with object in the same
+  // format as tokens returned from `tokenizer().getToken()`. Note
+  // that you are not allowed to call the parser from the
+  // callback—that will corrupt its internal state.
+  onToken: null,
+  // A function can be passed as `onComment` option, which will
+  // cause Acorn to call that function with `(block, text, start,
+  // end)` parameters whenever a comment is skipped. `block` is a
+  // boolean indicating whether this is a block (`/* */`) comment,
+  // `text` is the content of the comment, and `start` and `end` are
+  // character offsets that denote the start and end of the comment.
+  // When the `locations` option is on, two more parameters are
+  // passed, the full `{line, column}` locations of the start and
+  // end of the comments. Note that you are not allowed to call the
+  // parser from the callback—that will corrupt its internal state.
+  onComment: null,
+  // Nodes have their start and end characters offsets recorded in
+  // `start` and `end` properties (directly on the node, rather than
+  // the `loc` object, which holds line/column data. To also add a
+  // [semi-standardized][range] `range` property holding a `[start,
+  // end]` array with the same numbers, set the `ranges` option to
+  // `true`.
+  //
+  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+  ranges: false,
+  // It is possible to parse multiple files into a single AST by
+  // passing the tree produced by parsing the first file as
+  // `program` option in subsequent parses. This will add the
+  // toplevel forms of the parsed file to the `Program` (top) node
+  // of an existing parse tree.
+  program: null,
+  // When `locations` is on, you can pass this to record the source
+  // file in every node's `loc` object.
+  sourceFile: null,
+  // This value, if given, is stored in every node, whether
+  // `locations` is on or off.
+  directSourceFile: null,
+  // When enabled, parenthesized expressions are represented by
+  // (non-standard) ParenthesizedExpression nodes
+  preserveParens: false,
+  plugins: {}
+};
 
-  if (!Buffer.isEncoding(encoding)) {
-    throw new TypeError('"encoding" must be a valid string encoding')
-  }
+// Interpret and default an options object
 
-  var length = byteLength(string, encoding) | 0
-  that = createBuffer(that, length)
+function getOptions(opts) {
+  var options = {};
 
-  var actual = that.write(string, encoding)
+  for (var opt in defaultOptions)
+    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
 
-  if (actual !== length) {
-    // Writing a hex string, for example, that contains invalid characters will
-    // cause everything after the first invalid character to be ignored. (e.g.
-    // 'abxxcd' will be treated as 'ab')
-    that = that.slice(0, actual)
+  if (options.ecmaVersion >= 2015)
+    { options.ecmaVersion -= 2009; }
+
+  if (options.allowReserved == null)
+    { options.allowReserved = options.ecmaVersion < 5; }
+
+  if (isArray(options.onToken)) {
+    var tokens = options.onToken;
+    options.onToken = function (token) { return tokens.push(token); };
   }
+  if (isArray(options.onComment))
+    { options.onComment = pushComment(options, options.onComment); }
 
-  return that
+  return options
 }
 
-function fromArrayLike (that, array) {
-  var length = array.length < 0 ? 0 : checked(array.length) | 0
-  that = createBuffer(that, length)
-  for (var i = 0; i < length; i += 1) {
-    that[i] = array[i] & 255
+function pushComment(options, array) {
+  return function(block, text, start, end, startLoc, endLoc) {
+    var comment = {
+      type: block ? "Block" : "Line",
+      value: text,
+      start: start,
+      end: end
+    };
+    if (options.locations)
+      { comment.loc = new SourceLocation(this, startLoc, endLoc); }
+    if (options.ranges)
+      { comment.range = [start, end]; }
+    array.push(comment);
   }
-  return that
 }
 
-function fromArrayBuffer (that, array, byteOffset, length) {
-  array.byteLength // this throws if `array` is not a valid ArrayBuffer
+// Registered plugins
+var plugins = {};
 
-  if (byteOffset < 0 || array.byteLength < byteOffset) {
-    throw new RangeError('\'offset\' is out of bounds')
-  }
+function keywordRegexp(words) {
+  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
+}
 
-  if (array.byteLength < byteOffset + (length || 0)) {
-    throw new RangeError('\'length\' is out of bounds')
-  }
-
-  if (byteOffset === undefined && length === undefined) {
-    array = new Uint8Array(array)
-  } else if (length === undefined) {
-    array = new Uint8Array(array, byteOffset)
-  } else {
-    array = new Uint8Array(array, byteOffset, length)
+var Parser = function Parser(options, input, startPos) {
+  this.options = options = getOptions(options);
+  this.sourceFile = options.sourceFile;
+  this.keywords = keywordRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5]);
+  var reserved = "";
+  if (!options.allowReserved) {
+    for (var v = options.ecmaVersion;; v--)
+      { if (reserved = reservedWords[v]) { break } }
+    if (options.sourceType == "module") { reserved += " await"; }
   }
+  this.reservedWords = keywordRegexp(reserved);
+  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
+  this.reservedWordsStrict = keywordRegexp(reservedStrict);
+  this.reservedWordsStrictBind = keywordRegexp(reservedStrict + " " + reservedWords.strictBind);
+  this.input = String(input);
 
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    // Return an augmented `Uint8Array` instance, for best performance
-    that = array
-    that.__proto__ = Buffer.prototype
-  } else {
-    // Fallback: Return an object instance of the Buffer class
-    that = fromArrayLike(that, array)
-  }
-  return that
-}
+  // Used to signal to callers of `readWord1` whether the word
+  // contained any escape sequences. This is needed because words with
+  // escape sequences must not be interpreted as keywords.
+  this.containsEsc = false;
 
-function fromObject (that, obj) {
-  if (Buffer.isBuffer(obj)) {
-    var len = checked(obj.length) | 0
-    that = createBuffer(that, len)
+  // Load plugins
+  this.loadPlugins(options.plugins);
 
-    if (that.length === 0) {
-      return that
-    }
+  // Set up token state
 
-    obj.copy(that, 0, 0, len)
-    return that
+  // The current position of the tokenizer in the input.
+  if (startPos) {
+    this.pos = startPos;
+    this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
+    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+  } else {
+    this.pos = this.lineStart = 0;
+    this.curLine = 1;
   }
 
-  if (obj) {
-    if ((typeof ArrayBuffer !== 'undefined' &&
-        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
-      if (typeof obj.length !== 'number' || isnan(obj.length)) {
-        return createBuffer(that, 0)
-      }
-      return fromArrayLike(that, obj)
-    }
+  // Properties of the current token:
+  // Its type
+  this.type = types.eof;
+  // For tokens that include more information than their type, the value
+  this.value = null;
+  // Its start and end offset
+  this.start = this.end = this.pos;
+  // And, if locations are used, the {line, column} object
+  // corresponding to those offsets
+  this.startLoc = this.endLoc = this.curPosition();
 
-    if (obj.type === 'Buffer' && isArray(obj.data)) {
-      return fromArrayLike(that, obj.data)
-    }
-  }
+  // Position information for the previous token
+  this.lastTokEndLoc = this.lastTokStartLoc = null;
+  this.lastTokStart = this.lastTokEnd = this.pos;
 
-  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
-}
+  // The context stack is used to superficially track syntactic
+  // context to predict whether a regular expression is allowed in a
+  // given position.
+  this.context = this.initialContext();
+  this.exprAllowed = true;
 
-function checked (length) {
-  // Note: cannot use `length < kMaxLength()` here because that fails when
-  // length is NaN (which is otherwise coerced to zero.)
-  if (length >= kMaxLength()) {
-    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
-                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
-  }
-  return length | 0
-}
+  // Figure out if it's a module code.
+  this.inModule = options.sourceType === "module";
+  this.strict = this.inModule || this.strictDirective(this.pos);
 
-function SlowBuffer (length) {
-  if (+length != length) { // eslint-disable-line eqeqeq
-    length = 0
-  }
-  return Buffer.alloc(+length)
-}
+  // Used to signify the start of a potential arrow function
+  this.potentialArrowAt = -1;
 
-Buffer.isBuffer = function isBuffer (b) {
-  return !!(b != null && b._isBuffer)
-}
+  // Flags to track whether we are in a function, a generator, an async function.
+  this.inFunction = this.inGenerator = this.inAsync = false;
+  // Positions to delayed-check that yield/await does not exist in default parameters.
+  this.yieldPos = this.awaitPos = 0;
+  // Labels in scope.
+  this.labels = [];
 
-Buffer.compare = function compare (a, b) {
-  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
-    throw new TypeError('Arguments must be Buffers')
-  }
+  // If enabled, skip leading hashbang line.
+  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
+    { this.skipLineComment(2); }
 
-  if (a === b) return 0
+  // Scope tracking for duplicate variable names (see scope.js)
+  this.scopeStack = [];
+  this.enterFunctionScope();
+};
 
-  var x = a.length
-  var y = b.length
+// DEPRECATED Kept for backwards compatibility until 3.0 in case a plugin uses them
+Parser.prototype.isKeyword = function isKeyword (word) { return this.keywords.test(word) };
+Parser.prototype.isReservedWord = function isReservedWord (word) { return this.reservedWords.test(word) };
 
-  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
-    if (a[i] !== b[i]) {
-      x = a[i]
-      y = b[i]
-      break
-    }
-  }
+Parser.prototype.extend = function extend (name, f) {
+  this[name] = f(this[name]);
+};
 
-  if (x < y) return -1
-  if (y < x) return 1
-  return 0
-}
+Parser.prototype.loadPlugins = function loadPlugins (pluginConfigs) {
+    var this$1 = this;
 
-Buffer.isEncoding = function isEncoding (encoding) {
-  switch (String(encoding).toLowerCase()) {
-    case 'hex':
-    case 'utf8':
-    case 'utf-8':
-    case 'ascii':
-    case 'latin1':
-    case 'binary':
-    case 'base64':
-    case 'ucs2':
-    case 'ucs-2':
-    case 'utf16le':
-    case 'utf-16le':
-      return true
-    default:
-      return false
+  for (var name in pluginConfigs) {
+    var plugin = plugins[name];
+    if (!plugin) { throw new Error("Plugin '" + name + "' not found") }
+    plugin(this$1, pluginConfigs[name]);
   }
-}
+};
 
-Buffer.concat = function concat (list, length) {
-  if (!isArray(list)) {
-    throw new TypeError('"list" argument must be an Array of Buffers')
-  }
+Parser.prototype.parse = function parse () {
+  var node = this.options.program || this.startNode();
+  this.nextToken();
+  return this.parseTopLevel(node)
+};
 
-  if (list.length === 0) {
-    return Buffer.alloc(0)
-  }
+var pp = Parser.prototype;
 
-  var i
-  if (length === undefined) {
-    length = 0
-    for (i = 0; i < list.length; ++i) {
-      length += list[i].length
-    }
-  }
+// ## Parser utilities
 
-  var buffer = Buffer.allocUnsafe(length)
-  var pos = 0
-  for (i = 0; i < list.length; ++i) {
-    var buf = list[i]
-    if (!Buffer.isBuffer(buf)) {
-      throw new TypeError('"list" argument must be an Array of Buffers')
-    }
-    buf.copy(buffer, pos)
-    pos += buf.length
-  }
-  return buffer
-}
+var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;
+pp.strictDirective = function(start) {
+  var this$1 = this;
 
-function byteLength (string, encoding) {
-  if (Buffer.isBuffer(string)) {
-    return string.length
-  }
-  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
-      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
-    return string.byteLength
-  }
-  if (typeof string !== 'string') {
-    string = '' + string
+  for (;;) {
+    skipWhiteSpace.lastIndex = start;
+    start += skipWhiteSpace.exec(this$1.input)[0].length;
+    var match = literal.exec(this$1.input.slice(start));
+    if (!match) { return false }
+    if ((match[1] || match[2]) == "use strict") { return true }
+    start += match[0].length;
   }
+};
 
-  var len = string.length
-  if (len === 0) return 0
+// Predicate that tests whether the next token is of the given
+// type, and if yes, consumes it as a side effect.
 
-  // Use a for loop to avoid recursion
-  var loweredCase = false
-  for (;;) {
-    switch (encoding) {
-      case 'ascii':
-      case 'latin1':
-      case 'binary':
-        return len
-      case 'utf8':
-      case 'utf-8':
-      case undefined:
-        return utf8ToBytes(string).length
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return len * 2
-      case 'hex':
-        return len >>> 1
-      case 'base64':
-        return base64ToBytes(string).length
-      default:
-        if (loweredCase) return utf8ToBytes(string).length // assume utf8
-        encoding = ('' + encoding).toLowerCase()
-        loweredCase = true
-    }
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true
+  } else {
+    return false
   }
-}
-Buffer.byteLength = byteLength
+};
 
-function slowToString (encoding, start, end) {
-  var loweredCase = false
-
-  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
-  // property of a typed array.
+// Tests whether parsed token is a contextual keyword.
 
-  // This behaves neither like String nor Uint8Array in that we set start/end
-  // to their upper/lower bounds if the value passed is out of range.
-  // undefined is handled specially as per ECMA-262 6th Edition,
-  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
-  if (start === undefined || start < 0) {
-    start = 0
-  }
-  // Return early if start > this.length. Done here to prevent potential uint32
-  // coercion fail below.
-  if (start > this.length) {
-    return ''
-  }
+pp.isContextual = function(name) {
+  return this.type === types.name && this.value === name && !this.containsEsc
+};
 
-  if (end === undefined || end > this.length) {
-    end = this.length
-  }
+// Consumes contextual keyword if possible.
 
-  if (end <= 0) {
-    return ''
-  }
+pp.eatContextual = function(name) {
+  if (!this.isContextual(name)) { return false }
+  this.next();
+  return true
+};
 
-  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
-  end >>>= 0
-  start >>>= 0
+// Asserts that following token is given contextual keyword.
 
-  if (end <= start) {
-    return ''
-  }
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) { this.unexpected(); }
+};
 
-  if (!encoding) encoding = 'utf8'
+// Test whether a semicolon can be inserted at the current position.
 
-  while (true) {
-    switch (encoding) {
-      case 'hex':
-        return hexSlice(this, start, end)
+pp.canInsertSemicolon = function() {
+  return this.type === types.eof ||
+    this.type === types.braceR ||
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
 
-      case 'utf8':
-      case 'utf-8':
-        return utf8Slice(this, start, end)
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
+    return true
+  }
+};
 
-      case 'ascii':
-        return asciiSlice(this, start, end)
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
 
-      case 'latin1':
-      case 'binary':
-        return latin1Slice(this, start, end)
+pp.semicolon = function() {
+  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+};
 
-      case 'base64':
-        return base64Slice(this, start, end)
+pp.afterTrailingComma = function(tokType, notNext) {
+  if (this.type == tokType) {
+    if (this.options.onTrailingComma)
+      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
+    if (!notNext)
+      { this.next(); }
+    return true
+  }
+};
 
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return utf16leSlice(this, start, end)
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
 
-      default:
-        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
-        encoding = (encoding + '').toLowerCase()
-        loweredCase = true
-    }
-  }
-}
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
 
-// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
-// Buffer instances.
-Buffer.prototype._isBuffer = true
+// Raise an unexpected token error.
 
-function swap (b, n, m) {
-  var i = b[n]
-  b[n] = b[m]
-  b[m] = i
-}
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
 
-Buffer.prototype.swap16 = function swap16 () {
-  var len = this.length
-  if (len % 2 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 16-bits')
-  }
-  for (var i = 0; i < len; i += 2) {
-    swap(this, i, i + 1)
-  }
-  return this
+function DestructuringErrors() {
+  this.shorthandAssign =
+  this.trailingComma =
+  this.parenthesizedAssign =
+  this.parenthesizedBind =
+  this.doubleProto =
+    -1;
 }
 
-Buffer.prototype.swap32 = function swap32 () {
-  var len = this.length
-  if (len % 4 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 32-bits')
-  }
-  for (var i = 0; i < len; i += 4) {
-    swap(this, i, i + 3)
-    swap(this, i + 1, i + 2)
-  }
-  return this
-}
+pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
+  if (!refDestructuringErrors) { return }
+  if (refDestructuringErrors.trailingComma > -1)
+    { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
+  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
+  if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
+};
 
-Buffer.prototype.swap64 = function swap64 () {
-  var len = this.length
-  if (len % 8 !== 0) {
-    throw new RangeError('Buffer size must be a multiple of 64-bits')
-  }
-  for (var i = 0; i < len; i += 8) {
-    swap(this, i, i + 7)
-    swap(this, i + 1, i + 6)
-    swap(this, i + 2, i + 5)
-    swap(this, i + 3, i + 4)
-  }
-  return this
-}
+pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+  if (!refDestructuringErrors) { return false }
+  var shorthandAssign = refDestructuringErrors.shorthandAssign;
+  var doubleProto = refDestructuringErrors.doubleProto;
+  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
+  if (shorthandAssign >= 0)
+    { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
+  if (doubleProto >= 0)
+    { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
+};
 
-Buffer.prototype.toString = function toString () {
-  var length = this.length | 0
-  if (length === 0) return ''
-  if (arguments.length === 0) return utf8Slice(this, 0, length)
-  return slowToString.apply(this, arguments)
-}
+pp.checkYieldAwaitInDefaultParams = function() {
+  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
+    { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
+  if (this.awaitPos)
+    { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
+};
 
-Buffer.prototype.equals = function equals (b) {
-  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
-  if (this === b) return true
-  return Buffer.compare(this, b) === 0
-}
+pp.isSimpleAssignTarget = function(expr) {
+  if (expr.type === "ParenthesizedExpression")
+    { return this.isSimpleAssignTarget(expr.expression) }
+  return expr.type === "Identifier" || expr.type === "MemberExpression"
+};
 
-Buffer.prototype.inspect = function inspect () {
-  var str = ''
-  var max = exports.INSPECT_MAX_BYTES
-  if (this.length > 0) {
-    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
-    if (this.length > max) str += ' ... '
-  }
-  return '<Buffer ' + str + '>'
-}
+var pp$1 = Parser.prototype;
 
-Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
-  if (!Buffer.isBuffer(target)) {
-    throw new TypeError('Argument must be a Buffer')
-  }
+// ### Statement parsing
 
-  if (start === undefined) {
-    start = 0
-  }
-  if (end === undefined) {
-    end = target ? target.length : 0
-  }
-  if (thisStart === undefined) {
-    thisStart = 0
-  }
-  if (thisEnd === undefined) {
-    thisEnd = this.length
-  }
+// Parse a program. Initializes the parser, reads any number of
+// statements, and wraps them in a Program node.  Optionally takes a
+// `program` argument.  If present, the statements will be appended
+// to its body instead of creating a new node.
 
-  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
-    throw new RangeError('out of range index')
-  }
+pp$1.parseTopLevel = function(node) {
+  var this$1 = this;
 
-  if (thisStart >= thisEnd && start >= end) {
-    return 0
-  }
-  if (thisStart >= thisEnd) {
-    return -1
+  var exports = {};
+  if (!node.body) { node.body = []; }
+  while (this.type !== types.eof) {
+    var stmt = this$1.parseStatement(true, true, exports);
+    node.body.push(stmt);
   }
-  if (start >= end) {
-    return 1
+  this.adaptDirectivePrologue(node.body);
+  this.next();
+  if (this.options.ecmaVersion >= 6) {
+    node.sourceType = this.options.sourceType;
   }
+  return this.finishNode(node, "Program")
+};
 
-  start >>>= 0
-  end >>>= 0
-  thisStart >>>= 0
-  thisEnd >>>= 0
-
-  if (this === target) return 0
+var loopLabel = {kind: "loop"};
+var switchLabel = {kind: "switch"};
 
-  var x = thisEnd - thisStart
-  var y = end - start
-  var len = Math.min(x, y)
-
-  var thisCopy = this.slice(thisStart, thisEnd)
-  var targetCopy = target.slice(start, end)
-
-  for (var i = 0; i < len; ++i) {
-    if (thisCopy[i] !== targetCopy[i]) {
-      x = thisCopy[i]
-      y = targetCopy[i]
-      break
-    }
+pp$1.isLet = function() {
+  if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+  if (nextCh === 91 || nextCh == 123) { return true } // '{' and '['
+  if (isIdentifierStart(nextCh, true)) {
+    var pos = next + 1;
+    while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
+    var ident = this.input.slice(next, pos);
+    if (!keywordRelationalOperator.test(ident)) { return true }
   }
+  return false
+};
 
-  if (x < y) return -1
-  if (y < x) return 1
-  return 0
-}
+// check 'async [no LineTerminator here] function'
+// - 'async /*foo*/ function' is OK.
+// - 'async /*\n*/ function' is invalid.
+pp$1.isAsyncFunction = function() {
+  if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
+    { return false }
 
-// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
-// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length;
+  return !lineBreak.test(this.input.slice(this.pos, next)) &&
+    this.input.slice(next, next + 8) === "function" &&
+    (next + 8 == this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
+};
+
+// Parse a single statement.
 //
-// Arguments:
-// - buffer - a Buffer to search
-// - val - a string, Buffer, or number
-// - byteOffset - an index into `buffer`; will be clamped to an int32
-// - encoding - an optional encoding, relevant is val is a string
-// - dir - true for indexOf, false for lastIndexOf
-function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
-  // Empty buffer means no match
-  if (buffer.length === 0) return -1
+// If expecting a statement and finding a slash operator, parse a
+// regular expression literal. This is to handle cases like
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
+// does not help.
 
-  // Normalize byteOffset
-  if (typeof byteOffset === 'string') {
-    encoding = byteOffset
-    byteOffset = 0
-  } else if (byteOffset > 0x7fffffff) {
-    byteOffset = 0x7fffffff
-  } else if (byteOffset < -0x80000000) {
-    byteOffset = -0x80000000
-  }
-  byteOffset = +byteOffset  // Coerce to Number.
-  if (isNaN(byteOffset)) {
-    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
-    byteOffset = dir ? 0 : (buffer.length - 1)
-  }
+pp$1.parseStatement = function(declaration, topLevel, exports) {
+  var starttype = this.type, node = this.startNode(), kind;
 
-  // Normalize byteOffset: negative offsets start from the end of the buffer
-  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
-  if (byteOffset >= buffer.length) {
-    if (dir) return -1
-    else byteOffset = buffer.length - 1
-  } else if (byteOffset < 0) {
-    if (dir) byteOffset = 0
-    else return -1
+  if (this.isLet()) {
+    starttype = types._var;
+    kind = "let";
   }
 
-  // Normalize val
-  if (typeof val === 'string') {
-    val = Buffer.from(val, encoding)
-  }
+  // Most types of statements are recognized by the keyword they
+  // start with. Many are trivial to parse, some require a bit of
+  // complexity.
 
-  // Finally, search either indexOf (if dir is true) or lastIndexOf
-  if (Buffer.isBuffer(val)) {
-    // Special case: looking for empty string/buffer always fails
-    if (val.length === 0) {
-      return -1
+  switch (starttype) {
+  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+  case types._debugger: return this.parseDebuggerStatement(node)
+  case types._do: return this.parseDoStatement(node)
+  case types._for: return this.parseForStatement(node)
+  case types._function:
+    if (!declaration && this.options.ecmaVersion >= 6) { this.unexpected(); }
+    return this.parseFunctionStatement(node, false)
+  case types._class:
+    if (!declaration) { this.unexpected(); }
+    return this.parseClass(node, true)
+  case types._if: return this.parseIfStatement(node)
+  case types._return: return this.parseReturnStatement(node)
+  case types._switch: return this.parseSwitchStatement(node)
+  case types._throw: return this.parseThrowStatement(node)
+  case types._try: return this.parseTryStatement(node)
+  case types._const: case types._var:
+    kind = kind || this.value;
+    if (!declaration && kind != "var") { this.unexpected(); }
+    return this.parseVarStatement(node, kind)
+  case types._while: return this.parseWhileStatement(node)
+  case types._with: return this.parseWithStatement(node)
+  case types.braceL: return this.parseBlock()
+  case types.semi: return this.parseEmptyStatement(node)
+  case types._export:
+  case types._import:
+    if (!this.options.allowImportExportEverywhere) {
+      if (!topLevel)
+        { this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
+      if (!this.inModule)
+        { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
     }
-    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
-  } else if (typeof val === 'number') {
-    val = val & 0xFF // Search for a byte value [0-255]
-    if (Buffer.TYPED_ARRAY_SUPPORT &&
-        typeof Uint8Array.prototype.indexOf === 'function') {
-      if (dir) {
-        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
-      } else {
-        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
-      }
+    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+
+    // If the statement does not start with a statement keyword or a
+    // brace, it's an ExpressionStatement or LabeledStatement. We
+    // simply start parsing an expression, and afterwards, if the
+    // next token is a colon and the expression was a simple
+    // Identifier node, we switch to interpreting it as a label.
+  default:
+    if (this.isAsyncFunction()) {
+      if (!declaration) { this.unexpected(); }
+      this.next();
+      return this.parseFunctionStatement(node, true)
     }
-    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
-  }
 
-  throw new TypeError('val must be string, number or Buffer')
-}
+    var maybeName = this.value, expr = this.parseExpression();
+    if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
+      { return this.parseLabeledStatement(node, maybeName, expr) }
+    else { return this.parseExpressionStatement(node, expr) }
+  }
+};
 
-function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
-  var indexSize = 1
-  var arrLength = arr.length
-  var valLength = val.length
+pp$1.parseBreakContinueStatement = function(node, keyword) {
+  var this$1 = this;
 
-  if (encoding !== undefined) {
-    encoding = String(encoding).toLowerCase()
-    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
-        encoding === 'utf16le' || encoding === 'utf-16le') {
-      if (arr.length < 2 || val.length < 2) {
-        return -1
-      }
-      indexSize = 2
-      arrLength /= 2
-      valLength /= 2
-      byteOffset /= 2
-    }
+  var isBreak = keyword == "break";
+  this.next();
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
+  else if (this.type !== types.name) { this.unexpected(); }
+  else {
+    node.label = this.parseIdent();
+    this.semicolon();
   }
 
-  function read (buf, i) {
-    if (indexSize === 1) {
-      return buf[i]
-    } else {
-      return buf.readUInt16BE(i * indexSize)
+  // Verify that there is an actual destination to break or
+  // continue to.
+  var i = 0;
+  for (; i < this.labels.length; ++i) {
+    var lab = this$1.labels[i];
+    if (node.label == null || lab.name === node.label.name) {
+      if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
+      if (node.label && isBreak) { break }
     }
   }
+  if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+};
 
-  var i
-  if (dir) {
-    var foundIndex = -1
-    for (i = byteOffset; i < arrLength; i++) {
-      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
-        if (foundIndex === -1) foundIndex = i
-        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
-      } else {
-        if (foundIndex !== -1) i -= i - foundIndex
-        foundIndex = -1
-      }
-    }
-  } else {
-    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
-    for (i = byteOffset; i >= 0; i--) {
-      var found = true
-      for (var j = 0; j < valLength; j++) {
-        if (read(arr, i + j) !== read(val, j)) {
-          found = false
-          break
-        }
-      }
-      if (found) return i
-    }
-  }
+pp$1.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement")
+};
 
-  return -1
-}
+pp$1.parseDoStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  this.expect(types._while);
+  node.test = this.parseParenExpression();
+  if (this.options.ecmaVersion >= 6)
+    { this.eat(types.semi); }
+  else
+    { this.semicolon(); }
+  return this.finishNode(node, "DoWhileStatement")
+};
 
-Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
-  return this.indexOf(val, byteOffset, encoding) !== -1
-}
+// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+// loop is non-trivial. Basically, we have to parse the init `var`
+// statement or expression, disallowing the `in` operator (see
+// the second parameter to `parseExpression`), and then check
+// whether the next token is `in` or `of`. When there is no init
+// part (semicolon immediately after the opening parenthesis), it
+// is a regular `for` loop.
 
-Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
-  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
-}
-
-Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
-  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
-}
-
-function hexWrite (buf, string, offset, length) {
-  offset = Number(offset) || 0
-  var remaining = buf.length - offset
-  if (!length) {
-    length = remaining
+pp$1.parseForStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  this.enterLexicalScope();
+  this.expect(types.parenL);
+  if (this.type === types.semi) { return this.parseFor(node, null) }
+  var isLet = this.isLet();
+  if (this.type === types._var || this.type === types._const || isLet) {
+    var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
+    this.next();
+    this.parseVar(init$1, true, kind);
+    this.finishNode(init$1, "VariableDeclaration");
+    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1 &&
+        !(kind !== "var" && init$1.declarations[0].init))
+      { return this.parseForIn(node, init$1) }
+    return this.parseFor(node, init$1)
+  }
+  var refDestructuringErrors = new DestructuringErrors;
+  var init = this.parseExpression(true, refDestructuringErrors);
+  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+    this.toAssignable(init, false, refDestructuringErrors);
+    this.checkLVal(init);
+    return this.parseForIn(node, init)
   } else {
-    length = Number(length)
-    if (length > remaining) {
-      length = remaining
-    }
+    this.checkExpressionErrors(refDestructuringErrors, true);
   }
+  return this.parseFor(node, init)
+};
 
-  // must be an even number of digits
-  var strLen = string.length
-  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
+pp$1.parseFunctionStatement = function(node, isAsync) {
+  this.next();
+  return this.parseFunction(node, true, false, isAsync)
+};
 
-  if (length > strLen / 2) {
-    length = strLen / 2
-  }
-  for (var i = 0; i < length; ++i) {
-    var parsed = parseInt(string.substr(i * 2, 2), 16)
-    if (isNaN(parsed)) return i
-    buf[offset + i] = parsed
-  }
-  return i
-}
+pp$1.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  // allow function declarations in branches, but only in non-strict mode
+  node.consequent = this.parseStatement(!this.strict && this.type == types._function);
+  node.alternate = this.eat(types._else) ? this.parseStatement(!this.strict && this.type == types._function) : null;
+  return this.finishNode(node, "IfStatement")
+};
 
-function utf8Write (buf, string, offset, length) {
-  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
-}
+pp$1.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    { this.raise(this.start, "'return' outside of function"); }
+  this.next();
 
-function asciiWrite (buf, string, offset, length) {
-  return blitBuffer(asciiToBytes(string), buf, offset, length)
-}
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
 
-function latin1Write (buf, string, offset, length) {
-  return asciiWrite(buf, string, offset, length)
-}
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement")
+};
 
-function base64Write (buf, string, offset, length) {
-  return blitBuffer(base64ToBytes(string), buf, offset, length)
-}
+pp$1.parseSwitchStatement = function(node) {
+  var this$1 = this;
 
-function ucs2Write (buf, string, offset, length) {
-  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
-}
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(types.braceL);
+  this.labels.push(switchLabel);
+  this.enterLexicalScope();
 
-Buffer.prototype.write = function write (string, offset, length, encoding) {
-  // Buffer#write(string)
-  if (offset === undefined) {
-    encoding = 'utf8'
-    length = this.length
-    offset = 0
-  // Buffer#write(string, encoding)
-  } else if (length === undefined && typeof offset === 'string') {
-    encoding = offset
-    length = this.length
-    offset = 0
-  // Buffer#write(string, offset[, length][, encoding])
-  } else if (isFinite(offset)) {
-    offset = offset | 0
-    if (isFinite(length)) {
-      length = length | 0
-      if (encoding === undefined) encoding = 'utf8'
+  // Statements under must be grouped (by label) in SwitchCase
+  // nodes. `cur` is used to keep the node that we are currently
+  // adding statements to.
+
+  var cur;
+  for (var sawDefault = false; this.type != types.braceR;) {
+    if (this$1.type === types._case || this$1.type === types._default) {
+      var isCase = this$1.type === types._case;
+      if (cur) { this$1.finishNode(cur, "SwitchCase"); }
+      node.cases.push(cur = this$1.startNode());
+      cur.consequent = [];
+      this$1.next();
+      if (isCase) {
+        cur.test = this$1.parseExpression();
+      } else {
+        if (sawDefault) { this$1.raiseRecoverable(this$1.lastTokStart, "Multiple default clauses"); }
+        sawDefault = true;
+        cur.test = null;
+      }
+      this$1.expect(types.colon);
     } else {
-      encoding = length
-      length = undefined
+      if (!cur) { this$1.unexpected(); }
+      cur.consequent.push(this$1.parseStatement(true));
     }
-  // legacy write(string, encoding, offset, length) - remove in v0.13
-  } else {
-    throw new Error(
-      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
-    )
   }
+  this.exitLexicalScope();
+  if (cur) { this.finishNode(cur, "SwitchCase"); }
+  this.next(); // Closing brace
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement")
+};
 
-  var remaining = this.length - offset
-  if (length === undefined || length > remaining) length = remaining
-
-  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
-    throw new RangeError('Attempt to write outside buffer bounds')
-  }
+pp$1.parseThrowStatement = function(node) {
+  this.next();
+  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+    { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
+  node.argument = this.parseExpression();
+  this.semicolon();
+  return this.finishNode(node, "ThrowStatement")
+};
 
-  if (!encoding) encoding = 'utf8'
+// Reused empty array added for node fields that are always empty.
 
-  var loweredCase = false
-  for (;;) {
-    switch (encoding) {
-      case 'hex':
-        return hexWrite(this, string, offset, length)
+var empty = [];
 
-      case 'utf8':
-      case 'utf-8':
-        return utf8Write(this, string, offset, length)
+pp$1.parseTryStatement = function(node) {
+  this.next();
+  node.block = this.parseBlock();
+  node.handler = null;
+  if (this.type === types._catch) {
+    var clause = this.startNode();
+    this.next();
+    this.expect(types.parenL);
+    clause.param = this.parseBindingAtom();
+    this.enterLexicalScope();
+    this.checkLVal(clause.param, "let");
+    this.expect(types.parenR);
+    clause.body = this.parseBlock(false);
+    this.exitLexicalScope();
+    node.handler = this.finishNode(clause, "CatchClause");
+  }
+  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer)
+    { this.raise(node.start, "Missing catch or finally clause"); }
+  return this.finishNode(node, "TryStatement")
+};
 
-      case 'ascii':
-        return asciiWrite(this, string, offset, length)
+pp$1.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration")
+};
 
-      case 'latin1':
-      case 'binary':
-        return latin1Write(this, string, offset, length)
+pp$1.parseWhileStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "WhileStatement")
+};
 
-      case 'base64':
-        // Warning: maxLength not taken into account in base64Write
-        return base64Write(this, string, offset, length)
+pp$1.parseWithStatement = function(node) {
+  if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
+  this.next();
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement(false);
+  return this.finishNode(node, "WithStatement")
+};
 
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return ucs2Write(this, string, offset, length)
+pp$1.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement")
+};
 
-      default:
-        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
-        encoding = ('' + encoding).toLowerCase()
-        loweredCase = true
-    }
-  }
-}
+pp$1.parseLabeledStatement = function(node, maybeName, expr) {
+  var this$1 = this;
 
-Buffer.prototype.toJSON = function toJSON () {
-  return {
-    type: 'Buffer',
-    data: Array.prototype.slice.call(this._arr || this, 0)
-  }
-}
+  for (var i$1 = 0, list = this$1.labels; i$1 < list.length; i$1 += 1)
+    {
+    var label = list[i$1];
 
-function base64Slice (buf, start, end) {
-  if (start === 0 && end === buf.length) {
-    return base64.fromByteArray(buf)
-  } else {
-    return base64.fromByteArray(buf.slice(start, end))
+    if (label.name === maybeName)
+      { this$1.raise(expr.start, "Label '" + maybeName + "' is already declared");
+  } }
+  var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
+  for (var i = this.labels.length - 1; i >= 0; i--) {
+    var label$1 = this$1.labels[i];
+    if (label$1.statementStart == node.start) {
+      // Update information about previous labels on this node
+      label$1.statementStart = this$1.start;
+      label$1.kind = kind;
+    } else { break }
   }
-}
-
-function utf8Slice (buf, start, end) {
-  end = Math.min(buf.length, end)
-  var res = []
-
-  var i = start
-  while (i < end) {
-    var firstByte = buf[i]
-    var codePoint = null
-    var bytesPerSequence = (firstByte > 0xEF) ? 4
-      : (firstByte > 0xDF) ? 3
-      : (firstByte > 0xBF) ? 2
-      : 1
+  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
+  node.body = this.parseStatement(true);
+  if (node.body.type == "ClassDeclaration" ||
+      node.body.type == "VariableDeclaration" && node.body.kind != "var" ||
+      node.body.type == "FunctionDeclaration" && (this.strict || node.body.generator))
+    { this.raiseRecoverable(node.body.start, "Invalid labeled declaration"); }
+  this.labels.pop();
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement")
+};
 
-    if (i + bytesPerSequence <= end) {
-      var secondByte, thirdByte, fourthByte, tempCodePoint
+pp$1.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement")
+};
 
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 0x80) {
-            codePoint = firstByte
-          }
-          break
-        case 2:
-          secondByte = buf[i + 1]
-          if ((secondByte & 0xC0) === 0x80) {
-            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
-            if (tempCodePoint > 0x7F) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 3:
-          secondByte = buf[i + 1]
-          thirdByte = buf[i + 2]
-          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
-            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
-            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 4:
-          secondByte = buf[i + 1]
-          thirdByte = buf[i + 2]
-          fourthByte = buf[i + 3]
-          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
-            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
-            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
-              codePoint = tempCodePoint
-            }
-          }
-      }
-    }
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
 
-    if (codePoint === null) {
-      // we did not generate a valid codePoint so insert a
-      // replacement char (U+FFFD) and advance only 1 byte
-      codePoint = 0xFFFD
-      bytesPerSequence = 1
-    } else if (codePoint > 0xFFFF) {
-      // encode to utf16 (surrogate pair dance)
-      codePoint -= 0x10000
-      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
-      codePoint = 0xDC00 | codePoint & 0x3FF
-    }
+pp$1.parseBlock = function(createNewLexicalScope) {
+  var this$1 = this;
+  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
 
-    res.push(codePoint)
-    i += bytesPerSequence
+  var node = this.startNode();
+  node.body = [];
+  this.expect(types.braceL);
+  if (createNewLexicalScope) {
+    this.enterLexicalScope();
   }
-
-  return decodeCodePointsArray(res)
-}
-
-// Based on http://stackoverflow.com/a/22747272/680742, the browser with
-// the lowest limit is Chrome, with 0x10000 args.
-// We go 1 magnitude less, for safety
-var MAX_ARGUMENTS_LENGTH = 0x1000
-
-function decodeCodePointsArray (codePoints) {
-  var len = codePoints.length
-  if (len <= MAX_ARGUMENTS_LENGTH) {
-    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+  while (!this.eat(types.braceR)) {
+    var stmt = this$1.parseStatement(true);
+    node.body.push(stmt);
   }
-
-  // Decode in chunks to avoid "call stack size exceeded".
-  var res = ''
-  var i = 0
-  while (i < len) {
-    res += String.fromCharCode.apply(
-      String,
-      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
-    )
+  if (createNewLexicalScope) {
+    this.exitLexicalScope();
   }
-  return res
-}
+  return this.finishNode(node, "BlockStatement")
+};
 
-function asciiSlice (buf, start, end) {
-  var ret = ''
-  end = Math.min(buf.length, end)
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
 
-  for (var i = start; i < end; ++i) {
-    ret += String.fromCharCode(buf[i] & 0x7F)
-  }
-  return ret
-}
+pp$1.parseFor = function(node, init) {
+  node.init = init;
+  this.expect(types.semi);
+  node.test = this.type === types.semi ? null : this.parseExpression();
+  this.expect(types.semi);
+  node.update = this.type === types.parenR ? null : this.parseExpression();
+  this.expect(types.parenR);
+  this.exitLexicalScope();
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "ForStatement")
+};
 
-function latin1Slice (buf, start, end) {
-  var ret = ''
-  end = Math.min(buf.length, end)
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
 
-  for (var i = start; i < end; ++i) {
-    ret += String.fromCharCode(buf[i])
+pp$1.parseForIn = function(node, init) {
+  var type = this.type === types._in ? "ForInStatement" : "ForOfStatement";
+  this.next();
+  if (type == "ForInStatement") {
+    if (init.type === "AssignmentPattern" ||
+      (init.type === "VariableDeclaration" && init.declarations[0].init != null &&
+       (this.strict || init.declarations[0].id.type !== "Identifier")))
+      { this.raise(init.start, "Invalid assignment in for-in loop head"); }
   }
-  return ret
-}
+  node.left = init;
+  node.right = type == "ForInStatement" ? this.parseExpression() : this.parseMaybeAssign();
+  this.expect(types.parenR);
+  this.exitLexicalScope();
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, type)
+};
 
-function hexSlice (buf, start, end) {
-  var len = buf.length
+// Parse a list of variable declarations.
 
-  if (!start || start < 0) start = 0
-  if (!end || end < 0 || end > len) end = len
+pp$1.parseVar = function(node, isFor, kind) {
+  var this$1 = this;
 
-  var out = ''
-  for (var i = start; i < end; ++i) {
-    out += toHex(buf[i])
+  node.declarations = [];
+  node.kind = kind;
+  for (;;) {
+    var decl = this$1.startNode();
+    this$1.parseVarId(decl, kind);
+    if (this$1.eat(types.eq)) {
+      decl.init = this$1.parseMaybeAssign(isFor);
+    } else if (kind === "const" && !(this$1.type === types._in || (this$1.options.ecmaVersion >= 6 && this$1.isContextual("of")))) {
+      this$1.unexpected();
+    } else if (decl.id.type != "Identifier" && !(isFor && (this$1.type === types._in || this$1.isContextual("of")))) {
+      this$1.raise(this$1.lastTokEnd, "Complex binding patterns require an initialization value");
+    } else {
+      decl.init = null;
+    }
+    node.declarations.push(this$1.finishNode(decl, "VariableDeclarator"));
+    if (!this$1.eat(types.comma)) { break }
   }
-  return out
-}
+  return node
+};
 
-function utf16leSlice (buf, start, end) {
-  var bytes = buf.slice(start, end)
-  var res = ''
-  for (var i = 0; i < bytes.length; i += 2) {
-    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
-  }
-  return res
-}
+pp$1.parseVarId = function(decl, kind) {
+  decl.id = this.parseBindingAtom(kind);
+  this.checkLVal(decl.id, kind, false);
+};
 
-Buffer.prototype.slice = function slice (start, end) {
-  var len = this.length
-  start = ~~start
-  end = end === undefined ? len : ~~end
+// Parse a function declaration or literal (depending on the
+// `isStatement` parameter).
 
-  if (start < 0) {
-    start += len
-    if (start < 0) start = 0
-  } else if (start > len) {
-    start = len
-  }
+pp$1.parseFunction = function(node, isStatement, allowExpressionBody, isAsync) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6 && !isAsync)
+    { node.generator = this.eat(types.star); }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
 
-  if (end < 0) {
-    end += len
-    if (end < 0) end = 0
-  } else if (end > len) {
-    end = len
+  if (isStatement) {
+    node.id = isStatement === "nullableID" && this.type != types.name ? null : this.parseIdent();
+    if (node.id) {
+      this.checkLVal(node.id, "var");
+    }
   }
 
-  if (end < start) end = start
+  var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
+      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
+  this.inGenerator = node.generator;
+  this.inAsync = node.async;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.inFunction = true;
+  this.enterFunctionScope();
 
-  var newBuf
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    newBuf = this.subarray(start, end)
-    newBuf.__proto__ = Buffer.prototype
-  } else {
-    var sliceLen = end - start
-    newBuf = new Buffer(sliceLen, undefined)
-    for (var i = 0; i < sliceLen; ++i) {
-      newBuf[i] = this[i + start]
-    }
-  }
+  if (!isStatement)
+    { node.id = this.type == types.name ? this.parseIdent() : null; }
 
-  return newBuf
-}
+  this.parseFunctionParams(node);
+  this.parseFunctionBody(node, allowExpressionBody);
 
-/*
- * Need to make sure that buffer isn't trying to write out of bounds.
- */
-function checkOffset (offset, ext, length) {
-  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
-  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
-}
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+};
 
-Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) checkOffset(offset, byteLength, this.length)
+pp$1.parseFunctionParams = function(node) {
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+};
 
-  var val = this[offset]
-  var mul = 1
-  var i = 0
-  while (++i < byteLength && (mul *= 0x100)) {
-    val += this[offset + i] * mul
-  }
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
 
-  return val
-}
+pp$1.parseClass = function(node, isStatement) {
+  var this$1 = this;
 
-Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) {
-    checkOffset(offset, byteLength, this.length)
-  }
+  this.next();
 
-  var val = this[offset + --byteLength]
-  var mul = 1
-  while (byteLength > 0 && (mul *= 0x100)) {
-    val += this[offset + --byteLength] * mul
+  this.parseClassId(node, isStatement);
+  this.parseClassSuper(node);
+  var classBody = this.startNode();
+  var hadConstructor = false;
+  classBody.body = [];
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    var member = this$1.parseClassMember(classBody);
+    if (member && member.type === "MethodDefinition" && member.kind === "constructor") {
+      if (hadConstructor) { this$1.raise(member.start, "Duplicate constructor in the same class"); }
+      hadConstructor = true;
+    }
   }
+  node.body = this.finishNode(classBody, "ClassBody");
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+};
 
-  return val
-}
-
-Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 1, this.length)
-  return this[offset]
-}
+pp$1.parseClassMember = function(classBody) {
+  var this$1 = this;
 
-Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  return this[offset] | (this[offset + 1] << 8)
-}
+  if (this.eat(types.semi)) { return null }
 
-Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  return (this[offset] << 8) | this[offset + 1]
-}
+  var method = this.startNode();
+  var tryContextual = function (k, noLineBreak) {
+    if ( noLineBreak === void 0 ) noLineBreak = false;
 
-Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
+    var start = this$1.start, startLoc = this$1.startLoc;
+    if (!this$1.eatContextual(k)) { return false }
+    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+    if (method.key) { this$1.unexpected(); }
+    method.computed = false;
+    method.key = this$1.startNodeAt(start, startLoc);
+    method.key.name = k;
+    this$1.finishNode(method.key, "Identifier");
+    return false
+  };
 
-  return ((this[offset]) |
-      (this[offset + 1] << 8) |
-      (this[offset + 2] << 16)) +
-      (this[offset + 3] * 0x1000000)
-}
+  method.kind = "method";
+  method.static = tryContextual("static");
+  var isGenerator = this.eat(types.star);
+  var isAsync = false;
+  if (!isGenerator) {
+    if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+      isAsync = true;
+    } else if (tryContextual("get")) {
+      method.kind = "get";
+    } else if (tryContextual("set")) {
+      method.kind = "set";
+    }
+  }
+  if (!method.key) { this.parsePropertyName(method); }
+  var key = method.key;
+  if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
+      key.type === "Literal" && key.value === "constructor")) {
+    if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+    if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
+    if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
+    method.kind = "constructor";
+  } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+    this.raise(key.start, "Classes may not have a static property named prototype");
+  }
+  this.parseClassMethod(classBody, method, isGenerator, isAsync);
+  if (method.kind === "get" && method.value.params.length !== 0)
+    { this.raiseRecoverable(method.value.start, "getter should have no params"); }
+  if (method.kind === "set" && method.value.params.length !== 1)
+    { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
+  if (method.kind === "set" && method.value.params[0].type === "RestElement")
+    { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
+  return method
+};
 
-Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
+pp$1.parseClassMethod = function(classBody, method, isGenerator, isAsync) {
+  method.value = this.parseMethod(isGenerator, isAsync);
+  classBody.body.push(this.finishNode(method, "MethodDefinition"));
+};
 
-  return (this[offset] * 0x1000000) +
-    ((this[offset + 1] << 16) |
-    (this[offset + 2] << 8) |
-    this[offset + 3])
-}
+pp$1.parseClassId = function(node, isStatement) {
+  node.id = this.type === types.name ? this.parseIdent() : isStatement === true ? this.unexpected() : null;
+};
 
-Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) checkOffset(offset, byteLength, this.length)
+pp$1.parseClassSuper = function(node) {
+  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
+};
 
-  var val = this[offset]
-  var mul = 1
-  var i = 0
-  while (++i < byteLength && (mul *= 0x100)) {
-    val += this[offset + i] * mul
-  }
-  mul *= 0x80
+// Parses module export declaration.
 
-  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+pp$1.parseExport = function(node, exports) {
+  var this$1 = this;
 
-  return val
-}
+  this.next();
+  // export * from '...'
+  if (this.eat(types.star)) {
+    this.expectContextual("from");
+    if (this.type !== types.string) { this.unexpected(); }
+    node.source = this.parseExprAtom();
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(types._default)) { // export default ...
+    this.checkExport(exports, "default", this.lastTokStart);
+    var isAsync;
+    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
+      var fNode = this.startNode();
+      this.next();
+      if (isAsync) { this.next(); }
+      node.declaration = this.parseFunction(fNode, "nullableID", false, isAsync);
+    } else if (this.type === types._class) {
+      var cNode = this.startNode();
+      node.declaration = this.parseClass(cNode, "nullableID");
+    } else {
+      node.declaration = this.parseMaybeAssign();
+      this.semicolon();
+    }
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  // export var|const|let|function|class ...
+  if (this.shouldParseExportStatement()) {
+    node.declaration = this.parseStatement(true);
+    if (node.declaration.type === "VariableDeclaration")
+      { this.checkVariableExport(exports, node.declaration.declarations); }
+    else
+      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+    node.specifiers = [];
+    node.source = null;
+  } else { // export { x, y as z } [from '...']
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers(exports);
+    if (this.eatContextual("from")) {
+      if (this.type !== types.string) { this.unexpected(); }
+      node.source = this.parseExprAtom();
+    } else {
+      // check for keywords used as local names
+      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+        var spec = list[i];
 
-Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) checkOffset(offset, byteLength, this.length)
+        this$1.checkUnreserved(spec.local);
+      }
 
-  var i = byteLength
-  var mul = 1
-  var val = this[offset + --i]
-  while (i > 0 && (mul *= 0x100)) {
-    val += this[offset + --i] * mul
+      node.source = null;
+    }
+    this.semicolon();
   }
-  mul *= 0x80
-
-  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+  return this.finishNode(node, "ExportNamedDeclaration")
+};
 
-  return val
-}
-
-Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 1, this.length)
-  if (!(this[offset] & 0x80)) return (this[offset])
-  return ((0xff - this[offset] + 1) * -1)
-}
-
-Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  var val = this[offset] | (this[offset + 1] << 8)
-  return (val & 0x8000) ? val | 0xFFFF0000 : val
-}
+pp$1.checkExport = function(exports, name, pos) {
+  if (!exports) { return }
+  if (has(exports, name))
+    { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
+  exports[name] = true;
+};
 
-Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 2, this.length)
-  var val = this[offset + 1] | (this[offset] << 8)
-  return (val & 0x8000) ? val | 0xFFFF0000 : val
-}
+pp$1.checkPatternExport = function(exports, pat) {
+  var this$1 = this;
 
-Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
+  var type = pat.type;
+  if (type == "Identifier")
+    { this.checkExport(exports, pat.name, pat.start); }
+  else if (type == "ObjectPattern")
+    { for (var i = 0, list = pat.properties; i < list.length; i += 1)
+      {
+        var prop = list[i];
 
-  return (this[offset]) |
-    (this[offset + 1] << 8) |
-    (this[offset + 2] << 16) |
-    (this[offset + 3] << 24)
-}
+        this$1.checkPatternExport(exports, prop.value);
+      } }
+  else if (type == "ArrayPattern")
+    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
+      var elt = list$1[i$1];
 
-Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
+        if (elt) { this$1.checkPatternExport(exports, elt); }
+    } }
+  else if (type == "AssignmentPattern")
+    { this.checkPatternExport(exports, pat.left); }
+  else if (type == "ParenthesizedExpression")
+    { this.checkPatternExport(exports, pat.expression); }
+};
 
-  return (this[offset] << 24) |
-    (this[offset + 1] << 16) |
-    (this[offset + 2] << 8) |
-    (this[offset + 3])
-}
+pp$1.checkVariableExport = function(exports, decls) {
+  var this$1 = this;
 
-Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
-  return ieee754.read(this, offset, true, 23, 4)
-}
+  if (!exports) { return }
+  for (var i = 0, list = decls; i < list.length; i += 1)
+    {
+    var decl = list[i];
 
-Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 4, this.length)
-  return ieee754.read(this, offset, false, 23, 4)
-}
+    this$1.checkPatternExport(exports, decl.id);
+  }
+};
 
-Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 8, this.length)
-  return ieee754.read(this, offset, true, 52, 8)
-}
+pp$1.shouldParseExportStatement = function() {
+  return this.type.keyword === "var" ||
+    this.type.keyword === "const" ||
+    this.type.keyword === "class" ||
+    this.type.keyword === "function" ||
+    this.isLet() ||
+    this.isAsyncFunction()
+};
 
-Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
-  if (!noAssert) checkOffset(offset, 8, this.length)
-  return ieee754.read(this, offset, false, 52, 8)
-}
+// Parses a comma-separated list of module exports.
 
-function checkInt (buf, value, offset, ext, max, min) {
-  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
-  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
-  if (offset + ext > buf.length) throw new RangeError('Index out of range')
-}
+pp$1.parseExportSpecifiers = function(exports) {
+  var this$1 = this;
 
-Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
-  value = +value
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) {
-    var maxBytes = Math.pow(2, 8 * byteLength) - 1
-    checkInt(this, value, offset, byteLength, maxBytes, 0)
-  }
+  var nodes = [], first = true;
+  // export { x, y as z } [from '...']
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this$1.expect(types.comma);
+      if (this$1.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
 
-  var mul = 1
-  var i = 0
-  this[offset] = value & 0xFF
-  while (++i < byteLength && (mul *= 0x100)) {
-    this[offset + i] = (value / mul) & 0xFF
+    var node = this$1.startNode();
+    node.local = this$1.parseIdent(true);
+    node.exported = this$1.eatContextual("as") ? this$1.parseIdent(true) : node.local;
+    this$1.checkExport(exports, node.exported.name, node.exported.start);
+    nodes.push(this$1.finishNode(node, "ExportSpecifier"));
   }
+  return nodes
+};
 
-  return offset + byteLength
-}
-
-Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
-  value = +value
-  offset = offset | 0
-  byteLength = byteLength | 0
-  if (!noAssert) {
-    var maxBytes = Math.pow(2, 8 * byteLength) - 1
-    checkInt(this, value, offset, byteLength, maxBytes, 0)
-  }
+// Parses import declaration.
 
-  var i = byteLength - 1
-  var mul = 1
-  this[offset + i] = value & 0xFF
-  while (--i >= 0 && (mul *= 0x100)) {
-    this[offset + i] = (value / mul) & 0xFF
+pp$1.parseImport = function(node) {
+  this.next();
+  // import '...'
+  if (this.type === types.string) {
+    node.specifiers = empty;
+    node.source = this.parseExprAtom();
+  } else {
+    node.specifiers = this.parseImportSpecifiers();
+    this.expectContextual("from");
+    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
   }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration")
+};
 
-  return offset + byteLength
-}
+// Parses a comma-separated list of module imports.
 
-Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
-  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
-  this[offset] = (value & 0xff)
-  return offset + 1
-}
+pp$1.parseImportSpecifiers = function() {
+  var this$1 = this;
 
-function objectWriteUInt16 (buf, value, offset, littleEndian) {
-  if (value < 0) value = 0xffff + value + 1
-  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
-    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
-      (littleEndian ? i : 1 - i) * 8
+  var nodes = [], first = true;
+  if (this.type === types.name) {
+    // import defaultObj, { x, y as z } from '...'
+    var node = this.startNode();
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, "let");
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+    if (!this.eat(types.comma)) { return nodes }
   }
-}
-
-Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value & 0xff)
-    this[offset + 1] = (value >>> 8)
-  } else {
-    objectWriteUInt16(this, value, offset, true)
+  if (this.type === types.star) {
+    var node$1 = this.startNode();
+    this.next();
+    this.expectContextual("as");
+    node$1.local = this.parseIdent();
+    this.checkLVal(node$1.local, "let");
+    nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
+    return nodes
   }
-  return offset + 2
-}
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this$1.expect(types.comma);
+      if (this$1.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
 
-Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value >>> 8)
-    this[offset + 1] = (value & 0xff)
-  } else {
-    objectWriteUInt16(this, value, offset, false)
+    var node$2 = this$1.startNode();
+    node$2.imported = this$1.parseIdent(true);
+    if (this$1.eatContextual("as")) {
+      node$2.local = this$1.parseIdent();
+    } else {
+      this$1.checkUnreserved(node$2.imported);
+      node$2.local = node$2.imported;
+    }
+    this$1.checkLVal(node$2.local, "let");
+    nodes.push(this$1.finishNode(node$2, "ImportSpecifier"));
   }
-  return offset + 2
-}
+  return nodes
+};
 
-function objectWriteUInt32 (buf, value, offset, littleEndian) {
-  if (value < 0) value = 0xffffffff + value + 1
-  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
-    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+// Set `ExpressionStatement#directive` property for directive prologues.
+pp$1.adaptDirectivePrologue = function(statements) {
+  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
+    statements[i].directive = statements[i].expression.raw.slice(1, -1);
   }
-}
+};
+pp$1.isDirectiveCandidate = function(statement) {
+  return (
+    statement.type === "ExpressionStatement" &&
+    statement.expression.type === "Literal" &&
+    typeof statement.expression.value === "string" &&
+    // Reject parenthesized strings.
+    (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
+  )
+};
 
-Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset + 3] = (value >>> 24)
-    this[offset + 2] = (value >>> 16)
-    this[offset + 1] = (value >>> 8)
-    this[offset] = (value & 0xff)
-  } else {
-    objectWriteUInt32(this, value, offset, true)
-  }
-  return offset + 4
-}
+var pp$2 = Parser.prototype;
 
-Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value >>> 24)
-    this[offset + 1] = (value >>> 16)
-    this[offset + 2] = (value >>> 8)
-    this[offset + 3] = (value & 0xff)
-  } else {
-    objectWriteUInt32(this, value, offset, false)
-  }
-  return offset + 4
-}
+// Convert existing expression atom to assignable pattern
+// if possible.
 
-Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) {
-    var limit = Math.pow(2, 8 * byteLength - 1)
+pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+  var this$1 = this;
 
-    checkInt(this, value, offset, byteLength, limit - 1, -limit)
-  }
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "Identifier":
+      if (this.inAsync && node.name === "await")
+        { this.raise(node.start, "Can not use 'await' as identifier inside an async function"); }
+      break
 
-  var i = 0
-  var mul = 1
-  var sub = 0
-  this[offset] = value & 0xFF
-  while (++i < byteLength && (mul *= 0x100)) {
-    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
-      sub = 1
-    }
-    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
-  }
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "RestElement":
+      break
 
-  return offset + byteLength
-}
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      for (var i = 0, list = node.properties; i < list.length; i += 1)
+        {
+      var prop = list[i];
 
-Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) {
-    var limit = Math.pow(2, 8 * byteLength - 1)
+      this$1.toAssignable(prop, isBinding);
+    }
+      break
 
-    checkInt(this, value, offset, byteLength, limit - 1, -limit)
-  }
+    case "Property":
+      // AssignmentProperty has type == "Property"
+      if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
+      this.toAssignable(node.value, isBinding);
+      break
 
-  var i = byteLength - 1
-  var mul = 1
-  var sub = 0
-  this[offset + i] = value & 0xFF
-  while (--i >= 0 && (mul *= 0x100)) {
-    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
-      sub = 1
-    }
-    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
-  }
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      this.toAssignableList(node.elements, isBinding);
+      break
 
-  return offset + byteLength
-}
+    case "SpreadElement":
+      node.type = "RestElement";
+      this.toAssignable(node.argument, isBinding);
+      if (node.argument.type === "AssignmentPattern")
+        { this.raise(node.argument.start, "Rest elements cannot have a default value"); }
+      break
 
-Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
-  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
-  if (value < 0) value = 0xff + value + 1
-  this[offset] = (value & 0xff)
-  return offset + 1
-}
+    case "AssignmentExpression":
+      if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
+      node.type = "AssignmentPattern";
+      delete node.operator;
+      this.toAssignable(node.left, isBinding);
+      // falls through to AssignmentPattern
 
-Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value & 0xff)
-    this[offset + 1] = (value >>> 8)
-  } else {
-    objectWriteUInt16(this, value, offset, true)
-  }
-  return offset + 2
-}
+    case "AssignmentPattern":
+      break
 
-Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value >>> 8)
-    this[offset + 1] = (value & 0xff)
-  } else {
-    objectWriteUInt16(this, value, offset, false)
-  }
-  return offset + 2
-}
+    case "ParenthesizedExpression":
+      this.toAssignable(node.expression, isBinding);
+      break
 
-Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value & 0xff)
-    this[offset + 1] = (value >>> 8)
-    this[offset + 2] = (value >>> 16)
-    this[offset + 3] = (value >>> 24)
-  } else {
-    objectWriteUInt32(this, value, offset, true)
-  }
-  return offset + 4
-}
+    case "MemberExpression":
+      if (!isBinding) { break }
 
-Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
-  value = +value
-  offset = offset | 0
-  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
-  if (value < 0) value = 0xffffffff + value + 1
-  if (Buffer.TYPED_ARRAY_SUPPORT) {
-    this[offset] = (value >>> 24)
-    this[offset + 1] = (value >>> 16)
-    this[offset + 2] = (value >>> 8)
-    this[offset + 3] = (value & 0xff)
-  } else {
-    objectWriteUInt32(this, value, offset, false)
-  }
-  return offset + 4
-}
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+  return node
+};
 
-function checkIEEE754 (buf, value, offset, ext, max, min) {
-  if (offset + ext > buf.length) throw new RangeError('Index out of range')
-  if (offset < 0) throw new RangeError('Index out of range')
-}
+// Convert list of expression atoms to binding list.
 
-function writeFloat (buf, value, offset, littleEndian, noAssert) {
-  if (!noAssert) {
-    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+pp$2.toAssignableList = function(exprList, isBinding) {
+  var this$1 = this;
+
+  var end = exprList.length;
+  for (var i = 0; i < end; i++) {
+    var elt = exprList[i];
+    if (elt) { this$1.toAssignable(elt, isBinding); }
   }
-  ieee754.write(buf, value, offset, littleEndian, 23, 4)
-  return offset + 4
-}
+  if (end) {
+    var last = exprList[end - 1];
+    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
+      { this.unexpected(last.argument.start); }
+  }
+  return exprList
+};
 
-Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
-  return writeFloat(this, value, offset, true, noAssert)
-}
+// Parses spread element.
 
-Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
-  return writeFloat(this, value, offset, false, noAssert)
-}
+pp$2.parseSpread = function(refDestructuringErrors) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+  return this.finishNode(node, "SpreadElement")
+};
 
-function writeDouble (buf, value, offset, littleEndian, noAssert) {
-  if (!noAssert) {
-    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
-  }
-  ieee754.write(buf, value, offset, littleEndian, 52, 8)
-  return offset + 8
-}
+pp$2.parseRestBinding = function() {
+  var node = this.startNode();
+  this.next();
 
-Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
-  return writeDouble(this, value, offset, true, noAssert)
-}
+  // RestElement inside of a function parameter must be an identifier
+  if (this.options.ecmaVersion === 6 && this.type !== types.name)
+    { this.unexpected(); }
 
-Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
-  return writeDouble(this, value, offset, false, noAssert)
-}
+  node.argument = this.parseBindingAtom();
 
-// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
-Buffer.prototype.copy = function copy (target, targetStart, start, end) {
-  if (!start) start = 0
-  if (!end && end !== 0) end = this.length
-  if (targetStart >= target.length) targetStart = target.length
-  if (!targetStart) targetStart = 0
-  if (end > 0 && end < start) end = start
+  return this.finishNode(node, "RestElement")
+};
 
-  // Copy 0 bytes; we're done
-  if (end === start) return 0
-  if (target.length === 0 || this.length === 0) return 0
+// Parses lvalue (assignable) atom.
 
-  // Fatal error conditions
-  if (targetStart < 0) {
-    throw new RangeError('targetStart out of bounds')
-  }
-  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
-  if (end < 0) throw new RangeError('sourceEnd out of bounds')
+pp$2.parseBindingAtom = function() {
+  if (this.options.ecmaVersion >= 6) {
+    switch (this.type) {
+    case types.bracketL:
+      var node = this.startNode();
+      this.next();
+      node.elements = this.parseBindingList(types.bracketR, true, true);
+      return this.finishNode(node, "ArrayPattern")
 
-  // Are we oob?
-  if (end > this.length) end = this.length
-  if (target.length - targetStart < end - start) {
-    end = target.length - targetStart + start
+    case types.braceL:
+      return this.parseObj(true)
+    }
   }
+  return this.parseIdent()
+};
 
-  var len = end - start
-  var i
+pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var this$1 = this;
 
-  if (this === target && start < targetStart && targetStart < end) {
-    // descending copy from end
-    for (i = len - 1; i >= 0; --i) {
-      target[i + targetStart] = this[i + start]
-    }
-  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
-    // ascending copy from start
-    for (i = 0; i < len; ++i) {
-      target[i + targetStart] = this[i + start]
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (first) { first = false; }
+    else { this$1.expect(types.comma); }
+    if (allowEmpty && this$1.type === types.comma) {
+      elts.push(null);
+    } else if (allowTrailingComma && this$1.afterTrailingComma(close)) {
+      break
+    } else if (this$1.type === types.ellipsis) {
+      var rest = this$1.parseRestBinding();
+      this$1.parseBindingListItem(rest);
+      elts.push(rest);
+      if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
+      this$1.expect(close);
+      break
+    } else {
+      var elem = this$1.parseMaybeDefault(this$1.start, this$1.startLoc);
+      this$1.parseBindingListItem(elem);
+      elts.push(elem);
     }
-  } else {
-    Uint8Array.prototype.set.call(
-      target,
-      this.subarray(start, start + len),
-      targetStart
-    )
   }
+  return elts
+};
 
-  return len
-}
+pp$2.parseBindingListItem = function(param) {
+  return param
+};
 
-// Usage:
-//    buffer.fill(number[, offset[, end]])
-//    buffer.fill(buffer[, offset[, end]])
-//    buffer.fill(string[, offset[, end]][, encoding])
-Buffer.prototype.fill = function fill (val, start, end, encoding) {
-  // Handle string cases:
-  if (typeof val === 'string') {
-    if (typeof start === 'string') {
-      encoding = start
-      start = 0
-      end = this.length
-    } else if (typeof end === 'string') {
-      encoding = end
-      end = this.length
+// Parses assignment pattern around given atom if possible.
+
+pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+  left = left || this.parseBindingAtom();
+  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern")
+};
+
+// Verify that a node is an lval — something that can be assigned
+// to.
+// bindingType can be either:
+// 'var' indicating that the lval creates a 'var' binding
+// 'let' indicating that the lval creates a lexical ('let' or 'const') binding
+// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references
+
+pp$2.checkLVal = function(expr, bindingType, checkClashes) {
+  var this$1 = this;
+
+  switch (expr.type) {
+  case "Identifier":
+    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
+      { this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
+    if (checkClashes) {
+      if (has(checkClashes, expr.name))
+        { this.raiseRecoverable(expr.start, "Argument name clash"); }
+      checkClashes[expr.name] = true;
     }
-    if (val.length === 1) {
-      var code = val.charCodeAt(0)
-      if (code < 256) {
-        val = code
+    if (bindingType && bindingType !== "none") {
+      if (
+        bindingType === "var" && !this.canDeclareVarName(expr.name) ||
+        bindingType !== "var" && !this.canDeclareLexicalName(expr.name)
+      ) {
+        this.raiseRecoverable(expr.start, ("Identifier '" + (expr.name) + "' has already been declared"));
+      }
+      if (bindingType === "var") {
+        this.declareVarName(expr.name);
+      } else {
+        this.declareLexicalName(expr.name);
       }
     }
-    if (encoding !== undefined && typeof encoding !== 'string') {
-      throw new TypeError('encoding must be a string')
-    }
-    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
-      throw new TypeError('Unknown encoding: ' + encoding)
-    }
-  } else if (typeof val === 'number') {
-    val = val & 255
-  }
+    break
 
-  // Invalid ranges are not set to a default, so can range check early.
-  if (start < 0 || this.length < start || this.length < end) {
-    throw new RangeError('Out of range index')
-  }
+  case "MemberExpression":
+    if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+    break
 
-  if (end <= start) {
-    return this
+  case "ObjectPattern":
+    for (var i = 0, list = expr.properties; i < list.length; i += 1)
+      {
+    var prop = list[i];
+
+    this$1.checkLVal(prop, bindingType, checkClashes);
   }
+    break
 
-  start = start >>> 0
-  end = end === undefined ? this.length : end >>> 0
+  case "Property":
+    // AssignmentProperty has type == "Property"
+    this.checkLVal(expr.value, bindingType, checkClashes);
+    break
 
-  if (!val) val = 0
+  case "ArrayPattern":
+    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
+      var elem = list$1[i$1];
 
-  var i
-  if (typeof val === 'number') {
-    for (i = start; i < end; ++i) {
-      this[i] = val
-    }
-  } else {
-    var bytes = Buffer.isBuffer(val)
-      ? val
-      : utf8ToBytes(new Buffer(val, encoding).toString())
-    var len = bytes.length
-    for (i = 0; i < end - start; ++i) {
-      this[i + start] = bytes[i % len]
+    if (elem) { this$1.checkLVal(elem, bindingType, checkClashes); }
     }
-  }
+    break
 
-  return this
-}
+  case "AssignmentPattern":
+    this.checkLVal(expr.left, bindingType, checkClashes);
+    break
 
-// HELPER FUNCTIONS
-// ================
+  case "RestElement":
+    this.checkLVal(expr.argument, bindingType, checkClashes);
+    break
 
-var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+  case "ParenthesizedExpression":
+    this.checkLVal(expr.expression, bindingType, checkClashes);
+    break
 
-function base64clean (str) {
-  // Node strips out invalid characters like \n and \t from the string, base64-js does not
-  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
-  // Node converts strings with length < 2 to ''
-  if (str.length < 2) return ''
-  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
-  while (str.length % 4 !== 0) {
-    str = str + '='
+  default:
+    this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
   }
-  return str
-}
-
-function stringtrim (str) {
-  if (str.trim) return str.trim()
-  return str.replace(/^\s+|\s+$/g, '')
-}
+};
 
-function toHex (n) {
-  if (n < 16) return '0' + n.toString(16)
-  return n.toString(16)
-}
+// A recursive descent parser operates by defining functions for all
+// syntactic elements, and recursively calling those, each function
+// advancing the input stream and returning an AST node. Precedence
+// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
+// instead of `(!x)[1]` is handled by the fact that the parser
+// function that parses unary prefix operators is called first, and
+// in turn calls the function that parses `[]` subscripts — that
+// way, it'll receive the node for `x[1]` already parsed, and wraps
+// *that* in the unary operator node.
+//
+// Acorn uses an [operator precedence parser][opp] to handle binary
+// operator precedence, because it is much more compact than using
+// the technique outlined above, which uses different, nesting
+// functions to specify precedence, for all of the ten binary
+// precedence levels that JavaScript defines.
+//
+// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
 
-function utf8ToBytes (string, units) {
-  units = units || Infinity
-  var codePoint
-  var length = string.length
-  var leadSurrogate = null
-  var bytes = []
+var pp$3 = Parser.prototype;
 
-  for (var i = 0; i < length; ++i) {
-    codePoint = string.charCodeAt(i)
+// Check if property name clashes with already added.
+// Object/class getters and setters are not allowed to clash —
+// either with each other or with an init property — and in
+// strict mode, init properties are also not allowed to be repeated.
 
-    // is surrogate component
-    if (codePoint > 0xD7FF && codePoint < 0xE000) {
-      // last char was a lead
-      if (!leadSurrogate) {
-        // no lead yet
-        if (codePoint > 0xDBFF) {
-          // unexpected trail
-          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
-          continue
-        } else if (i + 1 === length) {
-          // unpaired lead
-          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
-          continue
-        }
-
-        // valid lead
-        leadSurrogate = codePoint
-
-        continue
-      }
-
-      // 2 leads in a row
-      if (codePoint < 0xDC00) {
-        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
-        leadSurrogate = codePoint
-        continue
+pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+    { return }
+  var key = prop.key;
+  var name;
+  switch (key.type) {
+  case "Identifier": name = key.name; break
+  case "Literal": name = String(key.value); break
+  default: return
+  }
+  var kind = prop.kind;
+  if (this.options.ecmaVersion >= 6) {
+    if (name === "__proto__" && kind === "init") {
+      if (propHash.proto) {
+        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }
+        // Backwards-compat kludge. Can be removed in version 6.0
+        else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
       }
-
-      // valid surrogate pair
-      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
-    } else if (leadSurrogate) {
-      // valid bmp char, but last char was a lead
-      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+      propHash.proto = true;
     }
-
-    leadSurrogate = null
-
-    // encode utf8
-    if (codePoint < 0x80) {
-      if ((units -= 1) < 0) break
-      bytes.push(codePoint)
-    } else if (codePoint < 0x800) {
-      if ((units -= 2) < 0) break
-      bytes.push(
-        codePoint >> 0x6 | 0xC0,
-        codePoint & 0x3F | 0x80
-      )
-    } else if (codePoint < 0x10000) {
-      if ((units -= 3) < 0) break
-      bytes.push(
-        codePoint >> 0xC | 0xE0,
-        codePoint >> 0x6 & 0x3F | 0x80,
-        codePoint & 0x3F | 0x80
-      )
-    } else if (codePoint < 0x110000) {
-      if ((units -= 4) < 0) break
-      bytes.push(
-        codePoint >> 0x12 | 0xF0,
-        codePoint >> 0xC & 0x3F | 0x80,
-        codePoint >> 0x6 & 0x3F | 0x80,
-        codePoint & 0x3F | 0x80
-      )
+    return
+  }
+  name = "$" + name;
+  var other = propHash[name];
+  if (other) {
+    var redefinition;
+    if (kind === "init") {
+      redefinition = this.strict && other.init || other.get || other.set;
     } else {
-      throw new Error('Invalid code point')
+      redefinition = other.init || other[kind];
     }
+    if (redefinition)
+      { this.raiseRecoverable(key.start, "Redefinition of property"); }
+  } else {
+    other = propHash[name] = {
+      init: false,
+      get: false,
+      set: false
+    };
   }
+  other[kind] = true;
+};
 
-  return bytes
-}
-
-function asciiToBytes (str) {
-  var byteArray = []
-  for (var i = 0; i < str.length; ++i) {
-    // Node's code seems to be doing this and not & 0x7F..
-    byteArray.push(str.charCodeAt(i) & 0xFF)
-  }
-  return byteArray
-}
-
-function utf16leToBytes (str, units) {
-  var c, hi, lo
-  var byteArray = []
-  for (var i = 0; i < str.length; ++i) {
-    if ((units -= 2) < 0) break
+// ### Expression parsing
 
-    c = str.charCodeAt(i)
-    hi = c >> 8
-    lo = c % 256
-    byteArray.push(lo)
-    byteArray.push(hi)
-  }
+// These nest, from the most general expression type at the top to
+// 'atomic', nondivisible expression types at the bottom. Most of
+// the functions will simply let the function(s) below them parse,
+// and, *if* the syntactic construct they handle is present, wrap
+// the AST node that the inner parser gave them in another node.
 
-  return byteArray
-}
+// Parse a full expression. The optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
 
-function base64ToBytes (str) {
-  return base64.toByteArray(base64clean(str))
-}
+pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+  var this$1 = this;
 
-function blitBuffer (src, dst, offset, length) {
-  for (var i = 0; i < length; ++i) {
-    if ((i + offset >= dst.length) || (i >= src.length)) break
-    dst[i + offset] = src[i]
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+  if (this.type === types.comma) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.expressions = [expr];
+    while (this.eat(types.comma)) { node.expressions.push(this$1.parseMaybeAssign(noIn, refDestructuringErrors)); }
+    return this.finishNode(node, "SequenceExpression")
   }
-  return i
-}
+  return expr
+};
 
-function isnan (val) {
-  return val !== val // eslint-disable-line no-self-compare
-}
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
 
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"base64-js":45,"ieee754":77,"isarray":80}],48:[function(require,module,exports){
-(function (Buffer){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+  if (this.inGenerator && this.isContextual("yield")) { return this.parseYield() }
 
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
+  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
+  if (refDestructuringErrors) {
+    oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+    oldTrailingComma = refDestructuringErrors.trailingComma;
+    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
+  } else {
+    refDestructuringErrors = new DestructuringErrors;
+    ownDestructuringErrors = true;
+  }
 
-function isArray(arg) {
-  if (Array.isArray) {
-    return Array.isArray(arg);
+  var startPos = this.start, startLoc = this.startLoc;
+  if (this.type == types.parenL || this.type == types.name)
+    { this.potentialArrowAt = this.start; }
+  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
+  if (this.type.isAssign) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.operator = this.value;
+    node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
+    if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }
+    refDestructuringErrors.shorthandAssign = -1; // reset because shorthand default was used correctly
+    this.checkLVal(left);
+    this.next();
+    node.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "AssignmentExpression")
+  } else {
+    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
   }
-  return objectToString(arg) === '[object Array]';
-}
-exports.isArray = isArray;
+  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
+  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
+  return left
+};
 
-function isBoolean(arg) {
-  return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
+// Parse a ternary conditional (`?:`) operator.
 
-function isNull(arg) {
-  return arg === null;
-}
-exports.isNull = isNull;
+pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprOps(noIn, refDestructuringErrors);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  if (this.eat(types.question)) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    this.expect(types.colon);
+    node.alternate = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "ConditionalExpression")
+  }
+  return expr
+};
 
-function isNullOrUndefined(arg) {
-  return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
+// Start the precedence parser.
 
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
+pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeUnary(refDestructuringErrors, false);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  return expr.start == startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+};
 
-function isString(arg) {
-  return typeof arg === 'string';
-}
-exports.isString = isString;
+// Parse binary operators with the operator precedence parsing
+// algorithm. `left` is the left-hand side of the operator.
+// `minPrec` provides context that allows the function to stop and
+// defer further parser to one of its callers when it encounters an
+// operator that has a lower precedence than the set it is parsing.
 
-function isSymbol(arg) {
-  return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
-
-function isUndefined(arg) {
-  return arg === void 0;
-}
-exports.isUndefined = isUndefined;
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+  var prec = this.type.binop;
+  if (prec != null && (!noIn || this.type !== types._in)) {
+    if (prec > minPrec) {
+      var logical = this.type === types.logicalOR || this.type === types.logicalAND;
+      var op = this.value;
+      this.next();
+      var startPos = this.start, startLoc = this.startLoc;
+      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
+      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+    }
+  }
+  return left
+};
 
-function isRegExp(re) {
-  return objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
+pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.operator = op;
+  node.right = right;
+  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
+};
 
-function isObject(arg) {
-  return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
+// Parse unary operators, both prefix and postfix.
 
-function isDate(d) {
-  return objectToString(d) === '[object Date]';
-}
-exports.isDate = isDate;
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+  var this$1 = this;
 
-function isError(e) {
-  return (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
+  var startPos = this.start, startLoc = this.startLoc, expr;
+  if (this.inAsync && this.isContextual("await")) {
+    expr = this.parseAwait();
+    sawUnary = true;
+  } else if (this.type.prefix) {
+    var node = this.startNode(), update = this.type === types.incDec;
+    node.operator = this.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary(null, true);
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    if (update) { this.checkLVal(node.argument); }
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
+      { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+    else { sawUnary = true; }
+    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else {
+    expr = this.parseExprSubscripts(refDestructuringErrors);
+    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+    while (this.type.postfix && !this.canInsertSemicolon()) {
+      var node$1 = this$1.startNodeAt(startPos, startLoc);
+      node$1.operator = this$1.value;
+      node$1.prefix = false;
+      node$1.argument = expr;
+      this$1.checkLVal(expr);
+      this$1.next();
+      expr = this$1.finishNode(node$1, "UpdateExpression");
+    }
+  }
 
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
+  if (!sawUnary && this.eat(types.starstar))
+    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  else
+    { return expr }
+};
 
-function isPrimitive(arg) {
-  return arg === null ||
-         typeof arg === 'boolean' ||
-         typeof arg === 'number' ||
-         typeof arg === 'string' ||
-         typeof arg === 'symbol' ||  // ES6 symbol
-         typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
+// Parse call, dot, and `[]`-subscript expressions.
 
-exports.isBuffer = Buffer.isBuffer;
+pp$3.parseExprSubscripts = function(refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprAtom(refDestructuringErrors);
+  var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")";
+  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }
+  var result = this.parseSubscripts(expr, startPos, startLoc);
+  if (refDestructuringErrors && result.type === "MemberExpression") {
+    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
+    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+  }
+  return result
+};
 
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
-}
+pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+  var this$1 = this;
 
-}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
-},{"../../is-buffer/index.js":79}],49:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
+      this.lastTokEnd == base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
+  for (var computed = (void 0);;) {
+    if ((computed = this$1.eat(types.bracketL)) || this$1.eat(types.dot)) {
+      var node = this$1.startNodeAt(startPos, startLoc);
+      node.object = base;
+      node.property = computed ? this$1.parseExpression() : this$1.parseIdent(true);
+      node.computed = !!computed;
+      if (computed) { this$1.expect(types.bracketR); }
+      base = this$1.finishNode(node, "MemberExpression");
+    } else if (!noCalls && this$1.eat(types.parenL)) {
+      var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this$1.yieldPos, oldAwaitPos = this$1.awaitPos;
+      this$1.yieldPos = 0;
+      this$1.awaitPos = 0;
+      var exprList = this$1.parseExprList(types.parenR, this$1.options.ecmaVersion >= 8, false, refDestructuringErrors);
+      if (maybeAsyncArrow && !this$1.canInsertSemicolon() && this$1.eat(types.arrow)) {
+        this$1.checkPatternErrors(refDestructuringErrors, false);
+        this$1.checkYieldAwaitInDefaultParams();
+        this$1.yieldPos = oldYieldPos;
+        this$1.awaitPos = oldAwaitPos;
+        return this$1.parseArrowExpression(this$1.startNodeAt(startPos, startLoc), exprList, true)
+      }
+      this$1.checkExpressionErrors(refDestructuringErrors, true);
+      this$1.yieldPos = oldYieldPos || this$1.yieldPos;
+      this$1.awaitPos = oldAwaitPos || this$1.awaitPos;
+      var node$1 = this$1.startNodeAt(startPos, startLoc);
+      node$1.callee = base;
+      node$1.arguments = exprList;
+      base = this$1.finishNode(node$1, "CallExpression");
+    } else if (this$1.type === types.backQuote) {
+      var node$2 = this$1.startNodeAt(startPos, startLoc);
+      node$2.tag = base;
+      node$2.quasi = this$1.parseTemplate({isTagged: true});
+      base = this$1.finishNode(node$2, "TaggedTemplateExpression");
+    } else {
+      return base
+    }
+  }
+};
 
-function EventEmitter() {
-  this._events = this._events || {};
-  this._maxListeners = this._maxListeners || undefined;
-}
-module.exports = EventEmitter;
+// Parse an atomic expression — either a single token that is an
+// expression, an expression started by a keyword like `function` or
+// `new`, or an expression wrapped in punctuation like `()`, `[]`,
+// or `{}`.
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+pp$3.parseExprAtom = function(refDestructuringErrors) {
+  var node, canBeArrow = this.potentialArrowAt == this.start;
+  switch (this.type) {
+  case types._super:
+    if (!this.inFunction)
+      { this.raise(this.start, "'super' outside of function or class"); }
+    node = this.startNode();
+    this.next();
+    // The `super` keyword can appear at below:
+    // SuperProperty:
+    //     super [ Expression ]
+    //     super . IdentifierName
+    // SuperCall:
+    //     super Arguments
+    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+      { this.unexpected(); }
+    return this.finishNode(node, "Super")
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
+  case types._this:
+    node = this.startNode();
+    this.next();
+    return this.finishNode(node, "ThisExpression")
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-EventEmitter.defaultMaxListeners = 10;
+  case types.name:
+    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
+    var id = this.parseIdent(this.type !== types.name);
+    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
+      { return this.parseFunction(this.startNodeAt(startPos, startLoc), false, false, true) }
+    if (canBeArrow && !this.canInsertSemicolon()) {
+      if (this.eat(types.arrow))
+        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+        id = this.parseIdent();
+        if (this.canInsertSemicolon() || !this.eat(types.arrow))
+          { this.unexpected(); }
+        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
+      }
+    }
+    return id
 
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function(n) {
-  if (!isNumber(n) || n < 0 || isNaN(n))
-    throw TypeError('n must be a positive number');
-  this._maxListeners = n;
-  return this;
-};
+  case types.regexp:
+    var value = this.value;
+    node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node
 
-EventEmitter.prototype.emit = function(type) {
-  var er, handler, len, args, i, listeners;
+  case types.num: case types.string:
+    return this.parseLiteral(this.value)
 
-  if (!this._events)
-    this._events = {};
+  case types._null: case types._true: case types._false:
+    node = this.startNode();
+    node.value = this.type === types._null ? null : this.type === types._true;
+    node.raw = this.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal")
 
-  // If there is no 'error' event listener then throw.
-  if (type === 'error') {
-    if (!this._events.error ||
-        (isObject(this._events.error) && !this._events.error.length)) {
-      er = arguments[1];
-      if (er instanceof Error) {
-        throw er; // Unhandled 'error' event
-      } else {
-        // At least give some kind of context to the user
-        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
-        err.context = er;
-        throw err;
-      }
-    }
-  }
-
-  handler = this._events[type];
-
-  if (isUndefined(handler))
-    return false;
-
-  if (isFunction(handler)) {
-    switch (arguments.length) {
-      // fast cases
-      case 1:
-        handler.call(this);
-        break;
-      case 2:
-        handler.call(this, arguments[1]);
-        break;
-      case 3:
-        handler.call(this, arguments[1], arguments[2]);
-        break;
-      // slower
-      default:
-        args = Array.prototype.slice.call(arguments, 1);
-        handler.apply(this, args);
+  case types.parenL:
+    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
+    if (refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
+        { refDestructuringErrors.parenthesizedAssign = start; }
+      if (refDestructuringErrors.parenthesizedBind < 0)
+        { refDestructuringErrors.parenthesizedBind = start; }
     }
-  } else if (isObject(handler)) {
-    args = Array.prototype.slice.call(arguments, 1);
-    listeners = handler.slice();
-    len = listeners.length;
-    for (i = 0; i < len; i++)
-      listeners[i].apply(this, args);
-  }
-
-  return true;
-};
+    return expr
 
-EventEmitter.prototype.addListener = function(type, listener) {
-  var m;
+  case types.bracketL:
+    node = this.startNode();
+    this.next();
+    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+    return this.finishNode(node, "ArrayExpression")
 
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
+  case types.braceL:
+    return this.parseObj(false, refDestructuringErrors)
 
-  if (!this._events)
-    this._events = {};
+  case types._function:
+    node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false)
 
-  // To avoid recursion in the case that type === "newListener"! Before
-  // adding it to the listeners, first emit "newListener".
-  if (this._events.newListener)
-    this.emit('newListener', type,
-              isFunction(listener.listener) ?
-              listener.listener : listener);
+  case types._class:
+    return this.parseClass(this.startNode(), false)
 
-  if (!this._events[type])
-    // Optimize the case of one listener. Don't need the extra array object.
-    this._events[type] = listener;
-  else if (isObject(this._events[type]))
-    // If we've already got an array, just append.
-    this._events[type].push(listener);
-  else
-    // Adding the second element, need to change to array.
-    this._events[type] = [this._events[type], listener];
+  case types._new:
+    return this.parseNew()
 
-  // Check for listener leak
-  if (isObject(this._events[type]) && !this._events[type].warned) {
-    if (!isUndefined(this._maxListeners)) {
-      m = this._maxListeners;
-    } else {
-      m = EventEmitter.defaultMaxListeners;
-    }
+  case types.backQuote:
+    return this.parseTemplate()
 
-    if (m && m > 0 && this._events[type].length > m) {
-      this._events[type].warned = true;
-      console.error('(node) warning: possible EventEmitter memory ' +
-                    'leak detected. %d listeners added. ' +
-                    'Use emitter.setMaxListeners() to increase limit.',
-                    this._events[type].length);
-      if (typeof console.trace === 'function') {
-        // not supported in IE 10
-        console.trace();
-      }
-    }
+  default:
+    this.unexpected();
   }
-
-  return this;
 };
 
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.once = function(type, listener) {
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
-
-  var fired = false;
-
-  function g() {
-    this.removeListener(type, g);
-
-    if (!fired) {
-      fired = true;
-      listener.apply(this, arguments);
-    }
-  }
-
-  g.listener = listener;
-  this.on(type, g);
-
-  return this;
+pp$3.parseLiteral = function(value) {
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  this.next();
+  return this.finishNode(node, "Literal")
 };
 
-// emits a 'removeListener' event iff the listener was removed
-EventEmitter.prototype.removeListener = function(type, listener) {
-  var list, position, length, i;
-
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
-
-  if (!this._events || !this._events[type])
-    return this;
+pp$3.parseParenExpression = function() {
+  this.expect(types.parenL);
+  var val = this.parseExpression();
+  this.expect(types.parenR);
+  return val
+};
 
-  list = this._events[type];
-  length = list.length;
-  position = -1;
+pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+  var this$1 = this;
 
-  if (list === listener ||
-      (isFunction(list.listener) && list.listener === listener)) {
-    delete this._events[type];
-    if (this._events.removeListener)
-      this.emit('removeListener', type, listener);
+  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
 
-  } else if (isObject(list)) {
-    for (i = length; i-- > 0;) {
-      if (list[i] === listener ||
-          (list[i].listener && list[i].listener === listener)) {
-        position = i;
-        break;
+    var innerStartPos = this.start, innerStartLoc = this.startLoc;
+    var exprList = [], first = true, lastIsComma = false;
+    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    while (this.type !== types.parenR) {
+      first ? first = false : this$1.expect(types.comma);
+      if (allowTrailingComma && this$1.afterTrailingComma(types.parenR, true)) {
+        lastIsComma = true;
+        break
+      } else if (this$1.type === types.ellipsis) {
+        spreadStart = this$1.start;
+        exprList.push(this$1.parseParenItem(this$1.parseRestBinding()));
+        if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
+        break
+      } else {
+        exprList.push(this$1.parseMaybeAssign(false, refDestructuringErrors, this$1.parseParenItem));
       }
     }
+    var innerEndPos = this.start, innerEndLoc = this.startLoc;
+    this.expect(types.parenR);
 
-    if (position < 0)
-      return this;
+    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      this.checkPatternErrors(refDestructuringErrors, false);
+      this.checkYieldAwaitInDefaultParams();
+      this.yieldPos = oldYieldPos;
+      this.awaitPos = oldAwaitPos;
+      return this.parseParenArrowList(startPos, startLoc, exprList)
+    }
 
-    if (list.length === 1) {
-      list.length = 0;
-      delete this._events[type];
+    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
+    if (spreadStart) { this.unexpected(spreadStart); }
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    this.yieldPos = oldYieldPos || this.yieldPos;
+    this.awaitPos = oldAwaitPos || this.awaitPos;
+
+    if (exprList.length > 1) {
+      val = this.startNodeAt(innerStartPos, innerStartLoc);
+      val.expressions = exprList;
+      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
     } else {
-      list.splice(position, 1);
+      val = exprList[0];
     }
+  } else {
+    val = this.parseParenExpression();
+  }
 
-    if (this._events.removeListener)
-      this.emit('removeListener', type, listener);
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(startPos, startLoc);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression")
+  } else {
+    return val
   }
+};
 
-  return this;
+pp$3.parseParenItem = function(item) {
+  return item
 };
 
-EventEmitter.prototype.removeAllListeners = function(type) {
-  var key, listeners;
+pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+};
 
-  if (!this._events)
-    return this;
+// New's precedence is slightly tricky. It must allow its argument to
+// be a `[]` or dot subscript expression, but not a call — at least,
+// not without wrapping it in parentheses. Thus, it uses the noCalls
+// argument to parseSubscripts to prevent it from consuming the
+// argument list.
 
-  // not listening for removeListener, no need to emit
-  if (!this._events.removeListener) {
-    if (arguments.length === 0)
-      this._events = {};
-    else if (this._events[type])
-      delete this._events[type];
-    return this;
-  }
+var empty$1 = [];
 
-  // emit removeListener for all listeners on all events
-  if (arguments.length === 0) {
-    for (key in this._events) {
-      if (key === 'removeListener') continue;
-      this.removeAllListeners(key);
-    }
-    this.removeAllListeners('removeListener');
-    this._events = {};
-    return this;
+pp$3.parseNew = function() {
+  var node = this.startNode();
+  var meta = this.parseIdent(true);
+  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
+    node.meta = meta;
+    var containsEsc = this.containsEsc;
+    node.property = this.parseIdent(true);
+    if (node.property.name !== "target" || containsEsc)
+      { this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
+    if (!this.inFunction)
+      { this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
+    return this.finishNode(node, "MetaProperty")
   }
+  var startPos = this.start, startLoc = this.startLoc;
+  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
+  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }
+  else { node.arguments = empty$1; }
+  return this.finishNode(node, "NewExpression")
+};
 
-  listeners = this._events[type];
-
-  if (isFunction(listeners)) {
-    this.removeListener(type, listeners);
-  } else if (listeners) {
-    // LIFO order
-    while (listeners.length)
-      this.removeListener(type, listeners[listeners.length - 1]);
-  }
-  delete this._events[type];
+// Parse template expression.
 
-  return this;
-};
+pp$3.parseTemplateElement = function(ref) {
+  var isTagged = ref.isTagged;
 
-EventEmitter.prototype.listeners = function(type) {
-  var ret;
-  if (!this._events || !this._events[type])
-    ret = [];
-  else if (isFunction(this._events[type]))
-    ret = [this._events[type]];
-  else
-    ret = this._events[type].slice();
-  return ret;
+  var elem = this.startNode();
+  if (this.type === types.invalidTemplate) {
+    if (!isTagged) {
+      this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
+    }
+    elem.value = {
+      raw: this.value,
+      cooked: null
+    };
+  } else {
+    elem.value = {
+      raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
+      cooked: this.value
+    };
+  }
+  this.next();
+  elem.tail = this.type === types.backQuote;
+  return this.finishNode(elem, "TemplateElement")
 };
 
-EventEmitter.prototype.listenerCount = function(type) {
-  if (this._events) {
-    var evlistener = this._events[type];
+pp$3.parseTemplate = function(ref) {
+  var this$1 = this;
+  if ( ref === void 0 ) ref = {};
+  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
 
-    if (isFunction(evlistener))
-      return 1;
-    else if (evlistener)
-      return evlistener.length;
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement({isTagged: isTagged});
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    this$1.expect(types.dollarBraceL);
+    node.expressions.push(this$1.parseExpression());
+    this$1.expect(types.braceR);
+    node.quasis.push(curElt = this$1.parseTemplateElement({isTagged: isTagged}));
   }
-  return 0;
+  this.next();
+  return this.finishNode(node, "TemplateLiteral")
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
-  return emitter.listenerCount(type);
+pp$3.isAsyncProp = function(prop) {
+  return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
+    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword) &&
+    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
 };
 
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
+// Parse an object literal or binding pattern.
 
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
+pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+  var this$1 = this;
 
-function isObject(arg) {
-  return typeof arg === 'object' && arg !== null;
-}
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
+  this.next();
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this$1.expect(types.comma);
+      if (this$1.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
 
-function isUndefined(arg) {
-  return arg === void 0;
-}
+    var prop = this$1.parseProperty(isPattern, refDestructuringErrors);
+    if (!isPattern) { this$1.checkPropClash(prop, propHash, refDestructuringErrors); }
+    node.properties.push(prop);
+  }
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+};
 
-},{}],50:[function(require,module,exports){
-'use strict';
+pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
+  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
+  if (this.options.ecmaVersion >= 6) {
+    prop.method = false;
+    prop.shorthand = false;
+    if (isPattern || refDestructuringErrors) {
+      startPos = this.start;
+      startLoc = this.startLoc;
+    }
+    if (!isPattern)
+      { isGenerator = this.eat(types.star); }
+  }
+  var containsEsc = this.containsEsc;
+  this.parsePropertyName(prop);
+  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
+    isAsync = true;
+    this.parsePropertyName(prop, refDestructuringErrors);
+  } else {
+    isAsync = false;
+  }
+  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
+  return this.finishNode(prop, "Property")
+};
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
+  if ((isGenerator || isAsync) && this.type === types.colon)
+    { this.unexpected(); }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  if (this.eat(types.colon)) {
+    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
+    prop.kind = "init";
+  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
+    if (isPattern) { this.unexpected(); }
+    prop.kind = "init";
+    prop.method = true;
+    prop.value = this.parseMethod(isGenerator, isAsync);
+  } else if (!isPattern && !containsEsc &&
+             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+             (prop.key.name === "get" || prop.key.name === "set") &&
+             (this.type != types.comma && this.type != types.braceR)) {
+    if (isGenerator || isAsync) { this.unexpected(); }
+    prop.kind = prop.key.name;
+    this.parsePropertyName(prop);
+    prop.value = this.parseMethod(false);
+    var paramCount = prop.kind === "get" ? 0 : 1;
+    if (prop.value.params.length !== paramCount) {
+      var start = prop.value.start;
+      if (prop.kind === "get")
+        { this.raiseRecoverable(start, "getter should have no params"); }
+      else
+        { this.raiseRecoverable(start, "setter should have exactly one param"); }
+    } else {
+      if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
+        { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
+    }
+  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+    this.checkUnreserved(prop.key);
+    prop.kind = "init";
+    if (isPattern) {
+      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+    } else if (this.type === types.eq && refDestructuringErrors) {
+      if (refDestructuringErrors.shorthandAssign < 0)
+        { refDestructuringErrors.shorthandAssign = this.start; }
+      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+    } else {
+      prop.value = prop.key;
+    }
+    prop.shorthand = true;
+  } else { this.unexpected(); }
+};
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+pp$3.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(types.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseMaybeAssign();
+      this.expect(types.bracketR);
+      return prop.key
+    } else {
+      prop.computed = false;
+    }
+  }
+  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(true)
+};
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+// Initialize empty function node.
 
-var FunctionBuilderBase = require('../function-builder-base');
-var CPUFunctionNode = require('./function-node');
+pp$3.initFunction = function(node) {
+  node.id = null;
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = false;
+    node.expression = false;
+  }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = false; }
+};
 
-/**
- * @class CPUFunctionBuilder
- *
- * @extends FunctionBuilderBase
- *
- * @desc Builds functions to execute on CPU from JavaScript function Strings
- *
- */
-module.exports = function (_FunctionBuilderBase) {
-  _inherits(CPUFunctionBuilder, _FunctionBuilderBase);
+// Parse object or class method.
 
-  function CPUFunctionBuilder() {
-    _classCallCheck(this, CPUFunctionBuilder);
+pp$3.parseMethod = function(isGenerator, isAsync) {
+  var node = this.startNode(), oldInGen = this.inGenerator, oldInAsync = this.inAsync,
+      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
 
-    var _this = _possibleConstructorReturn(this, (CPUFunctionBuilder.__proto__ || Object.getPrototypeOf(CPUFunctionBuilder)).call(this));
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6)
+    { node.generator = isGenerator; }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
 
-    _this.Node = CPUFunctionNode;
-    return _this;
-  }
+  this.inGenerator = node.generator;
+  this.inAsync = node.async;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.inFunction = true;
+  this.enterFunctionScope();
 
-  _createClass(CPUFunctionBuilder, [{
-    key: 'polyfillStandardFunctions',
-    value: function polyfillStandardFunctions() {}
-  }]);
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+  this.parseFunctionBody(node, false);
 
-  return CPUFunctionBuilder;
-}(FunctionBuilderBase);
-},{"../function-builder-base":55,"./function-node":51}],51:[function(require,module,exports){
-'use strict';
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, "FunctionExpression")
+};
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+// Parse arrow function expression with given parameters.
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+pp$3.parseArrowExpression = function(node, params, isAsync) {
+  var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
+      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  this.enterFunctionScope();
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  this.inGenerator = false;
+  this.inAsync = node.async;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.inFunction = true;
 
-var BaseFunctionNode = require('../function-node-base');
-var utils = require('../../core/utils');
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true);
 
-/**
- * @class CPUFunctionNode
- * 
- * @extends BaseFunctionNode
- *
- * @desc [INTERNAL] Represents a single function, inside JS
- *
- * <p>This handles all the raw state, converted state, etc. Of a single function.</p>
- *
- * @prop functionName         - {String}        Name of the function
- * @prop jsFunction           - {Function}   The JS Function the node represents
- * @prop jsFunctionString     - {String}        jsFunction.toString()
- * @prop paramNames           - {String[]}  Parameter names of the function
- * @prop paramTypes           - {String[]}  Shader land parameters type assumption
- * @prop isRootKernel         - {Boolean}       Special indicator, for kernel function
- * @prop webglFunctionString  - {String}        webgl converted function string
- * @prop openglFunctionString - {String}        opengl converted function string
- * @prop calledFunctions      - {String[]}  List of all the functions called
- * @prop initVariables        - {String[]}  List of variables initialized in the function
- * @prop readVariables        - {String[]}  List of variables read operations occur
- * @prop writeVariables       - {String[]}  List of variables write operations occur
- *
- */
-module.exports = function (_BaseFunctionNode) {
-	_inherits(CPUFunctionNode, _BaseFunctionNode);
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, "ArrowFunctionExpression")
+};
 
-	function CPUFunctionNode() {
-		_classCallCheck(this, CPUFunctionNode);
+// Parse function body and check parameters.
 
-		return _possibleConstructorReturn(this, (CPUFunctionNode.__proto__ || Object.getPrototypeOf(CPUFunctionNode)).apply(this, arguments));
-	}
+pp$3.parseFunctionBody = function(node, isArrowFunction) {
+  var isExpression = isArrowFunction && this.type !== types.braceL;
+  var oldStrict = this.strict, useStrict = false;
 
-	_createClass(CPUFunctionNode, [{
-		key: 'generate',
-		value: function generate() {
-			if (this.debug) {
-				console.log(this);
-			}
-			this.functionStringArray = this.astGeneric(this.getJsAST(), [], this);
-			this.functionString = this.functionStringArray.join('').trim();
-			return this.functionString;
-		}
+  if (isExpression) {
+    node.body = this.parseMaybeAssign();
+    node.expression = true;
+    this.checkParams(node, false);
+  } else {
+    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
+    if (!oldStrict || nonSimple) {
+      useStrict = this.strictDirective(this.end);
+      // If this is a strict mode function, verify that argument names
+      // are not repeated, and it does not try to bind the words `eval`
+      // or `arguments`.
+      if (useStrict && nonSimple)
+        { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
+    }
+    // Start a new scope with regard to labels and the `inFunction`
+    // flag (restore them to their old value afterwards).
+    var oldLabels = this.labels;
+    this.labels = [];
+    if (useStrict) { this.strict = true; }
 
-		/**
-   * @memberOf CPUFunctionNode#
-   * @function
-   * @name getFunctionPrototypeString
-   *
-   * @desc Returns the converted JS function
-   *
-   * @returns {String} function string, result is cached under this.getFunctionPrototypeString
-   *
-   */
+    // Add the params to varDeclaredNames to ensure that an error is thrown
+    // if a let/const declaration in the function clashes with one of the params.
+    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && this.isSimpleParamList(node.params));
+    node.body = this.parseBlock(false);
+    node.expression = false;
+    this.adaptDirectivePrologue(node.body.body);
+    this.labels = oldLabels;
+  }
+  this.exitFunctionScope();
 
-	}, {
-		key: 'getFunctionPrototypeString',
-		value: function getFunctionPrototypeString() {
-			if (this.webGlFunctionPrototypeString) {
-				return this.webGlFunctionPrototypeString;
-			}
-			return this.webGlFunctionPrototypeString = this.generate();
-		}
+  if (this.strict && node.id) {
+    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
+    this.checkLVal(node.id, "none");
+  }
+  this.strict = oldStrict;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astGeneric
-   *
-   * @desc Parses the abstract syntax tree for generically to its respective function
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed cpu string array
-   */
+pp$3.isSimpleParamList = function(params) {
+  for (var i = 0, list = params; i < list.length; i += 1)
+    {
+    var param = list[i];
 
-	}, {
-		key: 'astGeneric',
-		value: function astGeneric(ast, retArr, funcParam) {
-			if (ast === null) {
-				throw this.astErrorOutput('NULL ast', ast, funcParam);
-			} else {
-				if (Array.isArray(ast)) {
-					for (var i = 0; i < ast.length; i++) {
-						this.astGeneric(ast[i], retArr, funcParam);
-					}
-					return retArr;
-				}
+    if (param.type !== "Identifier") { return false
+  } }
+  return true
+};
 
-				switch (ast.type) {
-					case 'FunctionDeclaration':
-						return this.astFunctionDeclaration(ast, retArr, funcParam);
-					case 'FunctionExpression':
-						return this.astFunctionExpression(ast, retArr, funcParam);
-					case 'ReturnStatement':
-						return this.astReturnStatement(ast, retArr, funcParam);
-					case 'Literal':
-						return this.astLiteral(ast, retArr, funcParam);
-					case 'BinaryExpression':
-						return this.astBinaryExpression(ast, retArr, funcParam);
-					case 'Identifier':
-						return this.astIdentifierExpression(ast, retArr, funcParam);
-					case 'AssignmentExpression':
-						return this.astAssignmentExpression(ast, retArr, funcParam);
-					case 'ExpressionStatement':
-						return this.astExpressionStatement(ast, retArr, funcParam);
-					case 'EmptyStatement':
-						return this.astEmptyStatement(ast, retArr, funcParam);
-					case 'BlockStatement':
-						return this.astBlockStatement(ast, retArr, funcParam);
-					case 'IfStatement':
-						return this.astIfStatement(ast, retArr, funcParam);
-					case 'BreakStatement':
-						return this.astBreakStatement(ast, retArr, funcParam);
-					case 'ContinueStatement':
-						return this.astContinueStatement(ast, retArr, funcParam);
-					case 'ForStatement':
-						return this.astForStatement(ast, retArr, funcParam);
-					case 'WhileStatement':
-						return this.astWhileStatement(ast, retArr, funcParam);
-					case 'VariableDeclaration':
-						return this.astVariableDeclaration(ast, retArr, funcParam);
-					case 'VariableDeclarator':
-						return this.astVariableDeclarator(ast, retArr, funcParam);
-					case 'ThisExpression':
-						return this.astThisExpression(ast, retArr, funcParam);
-					case 'SequenceExpression':
-						return this.astSequenceExpression(ast, retArr, funcParam);
-					case 'UnaryExpression':
-						return this.astUnaryExpression(ast, retArr, funcParam);
-					case 'UpdateExpression':
-						return this.astUpdateExpression(ast, retArr, funcParam);
-					case 'LogicalExpression':
-						return this.astLogicalExpression(ast, retArr, funcParam);
-					case 'MemberExpression':
-						return this.astMemberExpression(ast, retArr, funcParam);
-					case 'CallExpression':
-						return this.astCallExpression(ast, retArr, funcParam);
-					case 'ArrayExpression':
-						return this.astArrayExpression(ast, retArr, funcParam);
-					case 'DebuggerStatement':
-						return this.astDebuggerStatement(ast, retArr, funcParam);
-				}
+// Checks function params for various disallowed patterns such as using "eval"
+// or "arguments" and duplicate parameters.
 
-				throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast, funcParam);
-			}
-		}
+pp$3.checkParams = function(node, allowDuplicates) {
+  var this$1 = this;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionDeclaration
-   *
-   * @desc Parses the abstract syntax tree for to its *named function declaration*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+  var nameHash = {};
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
 
-	}, {
-		key: 'astFunctionDeclaration',
-		value: function astFunctionDeclaration(ast, retArr, funcParam) {
-			if (this.addFunction) {
-				this.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
-			}
-			return retArr;
-		}
+    this$1.checkLVal(param, "var", allowDuplicates ? null : nameHash);
+  }
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionPrototype
-   * @static
-   *
-   * @desc Parses the abstract syntax tree for to its *named function prototype*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// Parses a comma-separated list of expressions, and returns them as
+// an array. `close` is the token type that ends the list, and
+// `allowEmpty` can be turned on to allow subsequent commas with
+// nothing in between them to be parsed as `null` (which is needed
+// for array literals).
 
-	}, {
-		key: 'astFunctionExpression',
+pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+  var this$1 = this;
 
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (!first) {
+      this$1.expect(types.comma);
+      if (allowTrailingComma && this$1.afterTrailingComma(close)) { break }
+    } else { first = false; }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionExpression
-   *
-   * @desc Parses the abstract syntax tree for to its *named function*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
-		value: function astFunctionExpression(ast, retArr, funcParam) {
+    var elt = (void 0);
+    if (allowEmpty && this$1.type === types.comma)
+      { elt = null; }
+    else if (this$1.type === types.ellipsis) {
+      elt = this$1.parseSpread(refDestructuringErrors);
+      if (refDestructuringErrors && this$1.type === types.comma && refDestructuringErrors.trailingComma < 0)
+        { refDestructuringErrors.trailingComma = this$1.start; }
+    } else {
+      elt = this$1.parseMaybeAssign(false, refDestructuringErrors);
+    }
+    elts.push(elt);
+  }
+  return elts
+};
 
-			// Setup function return type and name
-			if (!funcParam.isRootKernel) {
-				retArr.push('function');
-				funcParam.kernalAst = ast;
-				retArr.push(' ');
-				retArr.push(funcParam.functionName);
-				retArr.push('(');
+pp$3.checkUnreserved = function(ref) {
+  var start = ref.start;
+  var end = ref.end;
+  var name = ref.name;
 
-				// Arguments handling
-				for (var i = 0; i < funcParam.paramNames.length; ++i) {
-					var paramName = funcParam.paramNames[i];
+  if (this.inGenerator && name === "yield")
+    { this.raiseRecoverable(start, "Can not use 'yield' as identifier inside a generator"); }
+  if (this.inAsync && name === "await")
+    { this.raiseRecoverable(start, "Can not use 'await' as identifier inside an async function"); }
+  if (this.isKeyword(name))
+    { this.raise(start, ("Unexpected keyword '" + name + "'")); }
+  if (this.options.ecmaVersion < 6 &&
+    this.input.slice(start, end).indexOf("\\") != -1) { return }
+  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+  if (re.test(name)) {
+    if (!this.inAsync && name === "await")
+      { this.raiseRecoverable(start, "Can not use keyword 'await' outside an async function"); }
+    this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
+  }
+};
 
-					if (i > 0) {
-						retArr.push(', ');
-					}
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
 
-					retArr.push(' ');
-					retArr.push('user_');
-					retArr.push(paramName);
-				}
+pp$3.parseIdent = function(liberal, isBinding) {
+  var node = this.startNode();
+  if (liberal && this.options.allowReserved == "never") { liberal = false; }
+  if (this.type === types.name) {
+    node.name = this.value;
+  } else if (this.type.keyword) {
+    node.name = this.type.keyword;
 
-				// Function opening
-				retArr.push(') {\n');
-			}
+    // To fix https://github.com/acornjs/acorn/issues/575
+    // `class` and `function` keywords push new context into this.context.
+    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.
+    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword
+    if ((node.name === "class" || node.name === "function") &&
+        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
+      this.context.pop();
+    }
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  this.finishNode(node, "Identifier");
+  if (!liberal) { this.checkUnreserved(node); }
+  return node
+};
 
-			// Body statement iteration
-			for (var _i = 0; _i < ast.body.body.length; ++_i) {
-				this.astGeneric(ast.body.body[_i], retArr, funcParam);
-				retArr.push('\n');
-			}
+// Parses yield expression inside generator.
 
-			if (!funcParam.isRootKernel) {
-				// Function closing
-				retArr.push('}\n');
-			}
-			return retArr;
-		}
+pp$3.parseYield = function() {
+  if (!this.yieldPos) { this.yieldPos = this.start; }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astReturnStatement
-   *
-   * @desc Parses the abstract syntax tree for to *return* statement
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Object} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+  var node = this.startNode();
+  this.next();
+  if (this.type == types.semi || this.canInsertSemicolon() || (this.type != types.star && !this.type.startsExpr)) {
+    node.delegate = false;
+    node.argument = null;
+  } else {
+    node.delegate = this.eat(types.star);
+    node.argument = this.parseMaybeAssign();
+  }
+  return this.finishNode(node, "YieldExpression")
+};
 
-	}, {
-		key: 'astReturnStatement',
-		value: function astReturnStatement(ast, retArr, funcParam) {
-			if (funcParam.isRootKernel) {
-				retArr.push('kernelResult = ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-			} else if (funcParam.isSubKernel) {
-				retArr.push(funcParam.functionName + 'Result = ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-				retArr.push('return ' + funcParam.functionName + 'Result;');
-			} else {
-				retArr.push('return ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-			}
+pp$3.parseAwait = function() {
+  if (!this.awaitPos) { this.awaitPos = this.start; }
 
-			//throw this.astErrorOutput(
-			//	'Non main function return, is not supported : '+funcParam.currentFunctionNamespace,
-			//	ast, funcParam
-			//);
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeUnary(null, true);
+  return this.finishNode(node, "AwaitExpression")
+};
 
-			return retArr;
-		}
+var pp$4 = Parser.prototype;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astLiteral
-   *
-   * @desc Parses the abstract syntax tree for *literal value*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// This function is used to raise exceptions on parse errors. It
+// takes an offset integer (into the current `input`) to indicate
+// the location of the error, attaches the position to the end
+// of the error message, and then raises a `SyntaxError` with that
+// message.
 
-	}, {
-		key: 'astLiteral',
-		value: function astLiteral(ast, retArr, funcParam) {
+pp$4.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err
+};
 
-			// Reject non numeric literals
-			if (isNaN(ast.value)) {
-				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast, funcParam);
-			}
+pp$4.raiseRecoverable = pp$4.raise;
 
-			retArr.push(ast.value);
+pp$4.curPosition = function() {
+  if (this.options.locations) {
+    return new Position(this.curLine, this.pos - this.lineStart)
+  }
+};
 
-			return retArr;
-		}
+var pp$5 = Parser.prototype;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBinaryExpression
-   *
-   * @desc Parses the abstract syntax tree for *binary* expression
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// Object.assign polyfill
+var assign = Object.assign || function(target) {
+  var sources = [], len = arguments.length - 1;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
 
-	}, {
-		key: 'astBinaryExpression',
-		value: function astBinaryExpression(ast, retArr, funcParam) {
-			retArr.push('(');
-			this.astGeneric(ast.left, retArr, funcParam);
-			retArr.push(ast.operator);
-			this.astGeneric(ast.right, retArr, funcParam);
-			retArr.push(')');
-			return retArr;
-		}
-
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astIdentifierExpression
-   *
-   * @desc Parses the abstract syntax tree for *identifier* expression
-   *
-   * @param {Object} idtNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+  for (var i = 0, list = sources; i < list.length; i += 1) {
+    var source = list[i];
 
-	}, {
-		key: 'astIdentifierExpression',
-		value: function astIdentifierExpression(idtNode, retArr, funcParam) {
-			if (idtNode.type !== 'Identifier') {
-				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode, funcParam);
-			}
+    for (var key in source) {
+      if (has(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target
+};
 
-			switch (idtNode.name) {
-				case 'gpu_threadX':
-					retArr.push('threadId.x');
-					break;
-				case 'gpu_threadY':
-					retArr.push('threadId.y');
-					break;
-				case 'gpu_threadZ':
-					retArr.push('threadId.z');
-					break;
-				case 'gpu_outputX':
-					retArr.push('uOutputDim.x');
-					break;
-				case 'gpu_outputY':
-					retArr.push('uOutputDim.y');
-					break;
-				case 'gpu_outputZ':
-					retArr.push('uOutputDim.z');
-					break;
-				default:
-					if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
-						retArr.push('constants_' + idtNode.name);
-					} else {
-						var userParamName = funcParam.getUserParamName(idtNode.name);
-						if (userParamName !== null) {
-							retArr.push('user_' + userParamName);
-						} else {
-							retArr.push('user_' + idtNode.name);
-						}
-					}
-			}
+// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
 
-			return retArr;
-		}
+pp$5.enterFunctionScope = function() {
+  // var: a hash of var-declared names in the current lexical scope
+  // lexical: a hash of lexically-declared names in the current lexical scope
+  // childVar: a hash of var-declared names in all child lexical scopes of the current lexical scope (within the current function scope)
+  // parentLexical: a hash of lexically-declared names in all parent lexical scopes of the current lexical scope (within the current function scope)
+  this.scopeStack.push({var: {}, lexical: {}, childVar: {}, parentLexical: {}});
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astForStatement
-   *
-   * @desc Parses the abstract syntax tree forfor *for-loop* expression
-   *
-   * @param {Object} forNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed cpu string
-   */
+pp$5.exitFunctionScope = function() {
+  this.scopeStack.pop();
+};
 
-	}, {
-		key: 'astForStatement',
-		value: function astForStatement(forNode, retArr, funcParam) {
-			if (forNode.type !== 'ForStatement') {
-				throw this.astErrorOutput('Invalid for statment', forNode, funcParam);
-			}
+pp$5.enterLexicalScope = function() {
+  var parentScope = this.scopeStack[this.scopeStack.length - 1];
+  var childScope = {var: {}, lexical: {}, childVar: {}, parentLexical: {}};
 
-			if (forNode.test && forNode.test.type === 'BinaryExpression') {
-				if ((forNode.test.right.type === 'Identifier' || forNode.test.right.type === 'Literal') && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {
+  this.scopeStack.push(childScope);
+  assign(childScope.parentLexical, parentScope.lexical, parentScope.parentLexical);
+};
 
-					if (!this.loopMaxIterations) {
-						console.warn('Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior.');
-						console.warn('Set loopMaxIterations or use a for loop of fixed length to silence this message.');
-					}
+pp$5.exitLexicalScope = function() {
+  var childScope = this.scopeStack.pop();
+  var parentScope = this.scopeStack[this.scopeStack.length - 1];
 
-					retArr.push('for (');
-					this.astGeneric(forNode.init, retArr, funcParam);
-					if (retArr[retArr.length - 1] !== ';') {
-						retArr.push(';');
-					}
-					this.astGeneric(forNode.test.left, retArr, funcParam);
-					retArr.push(forNode.test.operator);
-					retArr.push('LOOP_MAX');
-					retArr.push(';');
-					this.astGeneric(forNode.update, retArr, funcParam);
-					retArr.push(')');
+  assign(parentScope.childVar, childScope.var, childScope.childVar);
+};
 
-					retArr.push('{\n');
-					retArr.push('if (');
-					this.astGeneric(forNode.test.left, retArr, funcParam);
-					retArr.push(forNode.test.operator);
-					this.astGeneric(forNode.test.right, retArr, funcParam);
-					retArr.push(') {\n');
-					if (forNode.body.type === 'BlockStatement') {
-						for (var i = 0; i < forNode.body.body.length; i++) {
-							this.astGeneric(forNode.body.body[i], retArr, funcParam);
-						}
-					} else {
-						this.astGeneric(forNode.body, retArr, funcParam);
-					}
-					retArr.push('} else {\n');
-					retArr.push('break;\n');
-					retArr.push('}\n');
-					retArr.push('}\n');
+/**
+ * A name can be declared with `var` if there are no variables with the same name declared with `let`/`const`
+ * in the current lexical scope or any of the parent lexical scopes in this function.
+ */
+pp$5.canDeclareVarName = function(name) {
+  var currentScope = this.scopeStack[this.scopeStack.length - 1];
 
-					return retArr;
-				} else if (forNode.init.declarations) {
-					var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));
-					var updateArgument = forNode.update.argument;
-					if (!Array.isArray(declarations) || declarations.length < 1) {
-						console.log(this.jsFunctionString);
-						throw new Error('Error: Incompatible for loop declaration');
-					}
+  return !has(currentScope.lexical, name) && !has(currentScope.parentLexical, name)
+};
 
-					if (declarations.length > 1) {
-						var initArgument = null;
-						for (var _i2 = 0; _i2 < declarations.length; _i2++) {
-							var declaration = declarations[_i2];
-							if (declaration.id.name === updateArgument.name) {
-								initArgument = declaration;
-								declarations.splice(_i2, 1);
-							} else {
-								retArr.push('var ');
-								this.astGeneric(declaration, retArr, funcParam);
-								retArr.push(';');
-							}
-						}
+/**
+ * A name can be declared with `let`/`const` if there are no variables with the same name declared with `let`/`const`
+ * in the current scope, and there are no variables with the same name declared with `var` in the current scope or in
+ * any child lexical scopes in this function.
+ */
+pp$5.canDeclareLexicalName = function(name) {
+  var currentScope = this.scopeStack[this.scopeStack.length - 1];
 
-						retArr.push('for (let ');
-						this.astGeneric(initArgument, retArr, funcParam);
-						retArr.push(';');
-					} else {
-						retArr.push('for (');
-						this.astGeneric(forNode.init, retArr, funcParam);
-					}
+  return !has(currentScope.lexical, name) && !has(currentScope.var, name) && !has(currentScope.childVar, name)
+};
 
-					this.astGeneric(forNode.test, retArr, funcParam);
-					retArr.push(';');
-					this.astGeneric(forNode.update, retArr, funcParam);
-					retArr.push(')');
-					this.astGeneric(forNode.body, retArr, funcParam);
-					return retArr;
-				}
-			}
+pp$5.declareVarName = function(name) {
+  this.scopeStack[this.scopeStack.length - 1].var[name] = true;
+};
 
-			throw this.astErrorOutput('Invalid for statement', forNode, funcParam);
-		}
+pp$5.declareLexicalName = function(name) {
+  this.scopeStack[this.scopeStack.length - 1].lexical[name] = true;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astWhileStatement
-   *
-   * @desc Parses the abstract syntax tree for *while* loop
-   *
-   *
-   * @param {Object} whileNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed openclgl string
-   */
+var Node = function Node(parser, pos, loc) {
+  this.type = "";
+  this.start = pos;
+  this.end = 0;
+  if (parser.options.locations)
+    { this.loc = new SourceLocation(parser, loc); }
+  if (parser.options.directSourceFile)
+    { this.sourceFile = parser.options.directSourceFile; }
+  if (parser.options.ranges)
+    { this.range = [pos, 0]; }
+};
 
-	}, {
-		key: 'astWhileStatement',
-		value: function astWhileStatement(whileNode, retArr, funcParam) {
-			if (whileNode.type !== 'WhileStatement') {
-				throw this.astErrorOutput('Invalid while statment', whileNode, funcParam);
-			}
+// Start an AST node, attaching a start offset.
 
-			retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
-			retArr.push('if (');
-			this.astGeneric(whileNode.test, retArr, funcParam);
-			retArr.push(') {\n');
-			this.astGeneric(whileNode.body, retArr, funcParam);
-			retArr.push('} else {\n');
-			retArr.push('break;\n');
-			retArr.push('}\n');
-			retArr.push('}\n');
+var pp$6 = Parser.prototype;
 
-			return retArr;
-		}
+pp$6.startNode = function() {
+  return new Node(this, this.start, this.startLoc)
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astAssignmentExpression
-   *
-   * @desc Parses the abstract syntax tree for *Assignment* Expression
-   *
-   * @param {Object} assNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+pp$6.startNodeAt = function(pos, loc) {
+  return new Node(this, pos, loc)
+};
 
-	}, {
-		key: 'astAssignmentExpression',
-		value: function astAssignmentExpression(assNode, retArr, funcParam) {
-			this.astGeneric(assNode.left, retArr, funcParam);
-			retArr.push(assNode.operator);
-			this.astGeneric(assNode.right, retArr, funcParam);
-			return retArr;
-		}
+// Finish an AST node, adding `type` and `end` properties.
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astEmptyStatement
-   *
-   * @desc Parses the abstract syntax tree for an *Empty* Statement
-   *
-   * @param {Object} eNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function finishNodeAt(node, type, pos, loc) {
+  node.type = type;
+  node.end = pos;
+  if (this.options.locations)
+    { node.loc.end = loc; }
+  if (this.options.ranges)
+    { node.range[1] = pos; }
+  return node
+}
 
-	}, {
-		key: 'astEmptyStatement',
-		value: function astEmptyStatement(eNode, retArr, funcParam) {
-			//retArr.push(';\n');
-			return retArr;
-		}
+pp$6.finishNode = function(node, type) {
+  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBlockStatement
-   *
-   * @desc Parses the abstract syntax tree for *Block* statement
-   *
-   * @param {Object} bNode - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// Finish node at given position
 
-	}, {
-		key: 'astBlockStatement',
-		value: function astBlockStatement(bNode, retArr, funcParam) {
-			retArr.push('{\n');
-			for (var i = 0; i < bNode.body.length; i++) {
-				this.astGeneric(bNode.body[i], retArr, funcParam);
-			}
-			retArr.push('}\n');
-			return retArr;
-		}
+pp$6.finishNodeAt = function(node, type, pos, loc) {
+  return finishNodeAt.call(this, node, type, pos, loc)
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astExpressionStatement
-   *
-   * @desc Parses the abstract syntax tree for *generic expression* statement
-   *
-   * @param {Object} esNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// The algorithm used to determine whether a regexp can appear at a
+// given point in the program is loosely based on sweet.js' approach.
+// See https://github.com/mozilla/sweet.js/wiki/design
 
-	}, {
-		key: 'astExpressionStatement',
-		value: function astExpressionStatement(esNode, retArr, funcParam) {
-			this.astGeneric(esNode.expression, retArr, funcParam);
-			retArr.push(';\n');
-			return retArr;
-		}
+var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
+  this.token = token;
+  this.isExpr = !!isExpr;
+  this.preserveSpace = !!preserveSpace;
+  this.override = override;
+  this.generator = !!generator;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astVariableDeclaration
-   *
-   * @desc Parses the abstract syntax tree for *Variable Declaration*
-   *
-   * @param {Object} vardecNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+var types$1 = {
+  b_stat: new TokContext("{", false),
+  b_expr: new TokContext("{", true),
+  b_tmpl: new TokContext("${", false),
+  p_stat: new TokContext("(", false),
+  p_expr: new TokContext("(", true),
+  q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
+  f_stat: new TokContext("function", false),
+  f_expr: new TokContext("function", true),
+  f_expr_gen: new TokContext("function", true, false, null, true),
+  f_gen: new TokContext("function", false, false, null, true)
+};
 
-	}, {
-		key: 'astVariableDeclaration',
-		value: function astVariableDeclaration(vardecNode, retArr, funcParam) {
-			retArr.push('var ');
-			for (var i = 0; i < vardecNode.declarations.length; i++) {
-				if (i > 0) {
-					retArr.push(',');
-				}
-				this.astGeneric(vardecNode.declarations[i], retArr, funcParam);
-			}
-			retArr.push(';');
-			return retArr;
-		}
+var pp$7 = Parser.prototype;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astVariableDeclarator
-   *
-   * @desc Parses the abstract syntax tree for *Variable Declarator*
-   *
-   * @param {Object} ivardecNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+pp$7.initialContext = function() {
+  return [types$1.b_stat]
+};
 
-	}, {
-		key: 'astVariableDeclarator',
-		value: function astVariableDeclarator(ivardecNode, retArr, funcParam) {
-			this.astGeneric(ivardecNode.id, retArr, funcParam);
-			if (ivardecNode.init !== null) {
-				retArr.push('=');
-				this.astGeneric(ivardecNode.init, retArr, funcParam);
-			}
-			return retArr;
-		}
+pp$7.braceIsBlock = function(prevType) {
+  var parent = this.curContext();
+  if (parent === types$1.f_expr || parent === types$1.f_stat)
+    { return true }
+  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
+    { return !parent.isExpr }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astIfStatement
-   *
-   * @desc Parses the abstract syntax tree for *If* Statement
-   *
-   * @param {Object} ifNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+  // The check for `tt.name && exprAllowed` detects whether we are
+  // after a `yield` or `of` construct. See the `updateContext` for
+  // `tt.name`.
+  if (prevType === types._return || prevType == types.name && this.exprAllowed)
+    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
+  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType == types.arrow)
+    { return true }
+  if (prevType == types.braceL)
+    { return parent === types$1.b_stat }
+  if (prevType == types._var || prevType == types.name)
+    { return false }
+  return !this.exprAllowed
+};
 
-	}, {
-		key: 'astIfStatement',
-		value: function astIfStatement(ifNode, retArr, funcParam) {
-			retArr.push('if (');
-			this.astGeneric(ifNode.test, retArr, funcParam);
-			retArr.push(')');
-			if (ifNode.consequent.type === 'BlockStatement') {
-				this.astGeneric(ifNode.consequent, retArr, funcParam);
-			} else {
-				retArr.push(' {\n');
-				this.astGeneric(ifNode.consequent, retArr, funcParam);
-				retArr.push('\n}\n');
-			}
+pp$7.inGeneratorContext = function() {
+  var this$1 = this;
 
-			if (ifNode.alternate) {
-				retArr.push('else ');
-				if (ifNode.alternate.type === 'BlockStatement') {
-					this.astGeneric(ifNode.alternate, retArr, funcParam);
-				} else {
-					retArr.push(' {\n');
-					this.astGeneric(ifNode.alternate, retArr, funcParam);
-					retArr.push('\n}\n');
-				}
-			}
-			return retArr;
-		}
+  for (var i = this.context.length - 1; i >= 1; i--) {
+    var context = this$1.context[i];
+    if (context.token === "function")
+      { return context.generator }
+  }
+  return false
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBreakStatement
-   *
-   * @desc Parses the abstract syntax tree for *Break* Statement
-   *
-   * @param {Object} brNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+pp$7.updateContext = function(prevType) {
+  var update, type = this.type;
+  if (type.keyword && prevType == types.dot)
+    { this.exprAllowed = false; }
+  else if (update = type.updateContext)
+    { update.call(this, prevType); }
+  else
+    { this.exprAllowed = type.beforeExpr; }
+};
 
-	}, {
-		key: 'astBreakStatement',
-		value: function astBreakStatement(brNode, retArr, funcParam) {
-			retArr.push('break;\n');
-			return retArr;
-		}
+// Token-specific context update code
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astContinueStatement
-   *
-   * @desc Parses the abstract syntax tree for *Continue* Statement
-   *
-   * @param {Object} crNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+types.parenR.updateContext = types.braceR.updateContext = function() {
+  if (this.context.length == 1) {
+    this.exprAllowed = true;
+    return
+  }
+  var out = this.context.pop();
+  if (out === types$1.b_stat && this.curContext().token === "function") {
+    out = this.context.pop();
+  }
+  this.exprAllowed = !out.isExpr;
+};
 
-	}, {
-		key: 'astContinueStatement',
-		value: function astContinueStatement(crNode, retArr, funcParam) {
-			retArr.push('continue;\n');
-			return retArr;
-		}
+types.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
+  this.exprAllowed = true;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astLogicalExpression
-   *
-   * @desc Parses the abstract syntax tree for *Logical* Expression
-   *
-   * @param {Object} logNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+types.dollarBraceL.updateContext = function() {
+  this.context.push(types$1.b_tmpl);
+  this.exprAllowed = true;
+};
 
-	}, {
-		key: 'astLogicalExpression',
-		value: function astLogicalExpression(logNode, retArr, funcParam) {
-			retArr.push('(');
-			this.astGeneric(logNode.left, retArr, funcParam);
-			retArr.push(logNode.operator);
-			this.astGeneric(logNode.right, retArr, funcParam);
-			retArr.push(')');
-			return retArr;
-		}
+types.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
+  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
+  this.exprAllowed = true;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astUpdateExpression
-   *
-   * @desc Parses the abstract syntax tree for *Update* Expression
-   *
-   * @param {Object} uNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+types.incDec.updateContext = function() {
+  // tokExprAllowed stays unchanged
+};
 
-	}, {
-		key: 'astUpdateExpression',
-		value: function astUpdateExpression(uNode, retArr, funcParam) {
-			if (uNode.prefix) {
-				retArr.push(uNode.operator);
-				this.astGeneric(uNode.argument, retArr, funcParam);
-			} else {
-				this.astGeneric(uNode.argument, retArr, funcParam);
-				retArr.push(uNode.operator);
-			}
+types._function.updateContext = types._class.updateContext = function(prevType) {
+  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
+      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
+    { this.context.push(types$1.f_expr); }
+  else
+    { this.context.push(types$1.f_stat); }
+  this.exprAllowed = false;
+};
 
-			return retArr;
-		}
+types.backQuote.updateContext = function() {
+  if (this.curContext() === types$1.q_tmpl)
+    { this.context.pop(); }
+  else
+    { this.context.push(types$1.q_tmpl); }
+  this.exprAllowed = false;
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astUnaryExpression
-   *
-   * @desc Parses the abstract syntax tree for *Unary* Expression
-   *
-   * @param {Object} uNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+types.star.updateContext = function(prevType) {
+  if (prevType == types._function) {
+    var index = this.context.length - 1;
+    if (this.context[index] === types$1.f_expr)
+      { this.context[index] = types$1.f_expr_gen; }
+    else
+      { this.context[index] = types$1.f_gen; }
+  }
+  this.exprAllowed = true;
+};
 
-	}, {
-		key: 'astUnaryExpression',
-		value: function astUnaryExpression(uNode, retArr, funcParam) {
-			if (uNode.prefix) {
-				retArr.push(uNode.operator);
-				this.astGeneric(uNode.argument, retArr, funcParam);
-			} else {
-				this.astGeneric(uNode.argument, retArr, funcParam);
-				retArr.push(uNode.operator);
-			}
+types.name.updateContext = function(prevType) {
+  var allowed = false;
+  if (this.options.ecmaVersion >= 6) {
+    if (this.value == "of" && !this.exprAllowed ||
+        this.value == "yield" && this.inGeneratorContext())
+      { allowed = true; }
+  }
+  this.exprAllowed = allowed;
+};
 
-			return retArr;
-		}
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astThisExpression
-   *
-   * @desc Parses the abstract syntax tree for *This* expression
-   *
-   * @param {Object} tNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+var Token = function Token(p) {
+  this.type = p.type;
+  this.value = p.value;
+  this.start = p.start;
+  this.end = p.end;
+  if (p.options.locations)
+    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
+  if (p.options.ranges)
+    { this.range = [p.start, p.end]; }
+};
 
-	}, {
-		key: 'astThisExpression',
-		value: function astThisExpression(tNode, retArr, funcParam) {
-			retArr.push('_this');
-			return retArr;
-		}
+// ## Tokenizer
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astMemberExpression
-   *
-   * @desc Parses the abstract syntax tree for *Member* Expression
-   *
-   * @param {Object} mNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+var pp$8 = Parser.prototype;
 
-	}, {
-		key: 'astMemberExpression',
-		value: function astMemberExpression(mNode, retArr, funcParam) {
-			if (mNode.computed) {
-				if (mNode.object.type === 'Identifier') {
-					this.astGeneric(mNode.object, retArr, funcParam);
-					retArr.push('[');
-					this.astGeneric(mNode.property, retArr, funcParam);
-					retArr.push(']');
-				} else {
-					this.astGeneric(mNode.object, retArr, funcParam);
-					var last = retArr.pop();
-					retArr.push('][');
-					this.astGeneric(mNode.property, retArr, funcParam);
-					retArr.push(last);
-				}
-			} else {
-				var unrolled = this.astMemberExpressionUnroll(mNode);
-				if (mNode.property.type === 'Identifier' && mNode.computed) {
-					unrolled = 'user_' + unrolled;
-				}
+// Are we running under Rhino?
+var isRhino = typeof Packages == "object" && Object.prototype.toString.call(Packages) == "[object JavaPackage]";
 
-				// Its a reference to `this`, add '_' before
-				if (unrolled.indexOf('this') === 0) {
-					unrolled = '_' + unrolled;
-				}
+// Move to the next token
 
-				switch (unrolled) {
-					case '_this.output.x':
-						retArr.push(this.output[0]);
-						break;
-					case '_this.output.y':
-						retArr.push(this.output[1]);
-						break;
-					case '_this.output.z':
-						retArr.push(this.output[2]);
-						break;
-					default:
-						retArr.push(unrolled);
-				}
-			}
-			return retArr;
-		}
-	}, {
-		key: 'astSequenceExpression',
-		value: function astSequenceExpression(sNode, retArr, funcParam) {
-			for (var i = 0; i < sNode.expressions.length; i++) {
-				if (i > 0) {
-					retArr.push(',');
-				}
-				this.astGeneric(sNode.expressions, retArr, funcParam);
-			}
-			return retArr;
-		}
-
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astCallExpression
-   *
-   * @desc Parses the abstract syntax tree for *call* expression
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns  {Array} the append retArr
-   */
-
-	}, {
-		key: 'astCallExpression',
-		value: function astCallExpression(ast, retArr, funcParam) {
-			if (ast.callee) {
-				// Get the full function call, unrolled
-				var funcName = this.astMemberExpressionUnroll(ast.callee);
-
-				// Register the function into the called registry
-				if (funcParam.calledFunctions.indexOf(funcName) < 0) {
-					funcParam.calledFunctions.push(funcName);
-				}
-				if (!funcParam.hasOwnProperty('funcName')) {
-					funcParam.calledFunctionsArguments[funcName] = [];
-				}
-
-				var functionArguments = [];
-				funcParam.calledFunctionsArguments[funcName].push(functionArguments);
-
-				// Call the function
-				retArr.push(funcName);
-
-				// Open arguments space
-				retArr.push('(');
-
-				// Add the vars
-				for (var i = 0; i < ast.arguments.length; ++i) {
-					var argument = ast.arguments[i];
-					if (i > 0) {
-						retArr.push(', ');
-					}
-					this.astGeneric(argument, retArr, funcParam);
-					if (argument.type === 'Identifier') {
-						var paramIndex = funcParam.paramNames.indexOf(argument.name);
-						if (paramIndex === -1) {
-							functionArguments.push(null);
-						} else {
-							functionArguments.push({
-								name: argument.name,
-								type: funcParam.paramTypes[paramIndex]
-							});
-						}
-					} else {
-						functionArguments.push(null);
-					}
-				}
-
-				// Close arguments space
-				retArr.push(')');
-
-				return retArr;
-			}
+pp$8.next = function() {
+  if (this.options.onToken)
+    { this.options.onToken(new Token(this)); }
 
-			// Failure, unknown expression
-			throw this.astErrorOutput('Unknown CallExpression', ast, funcParam);
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
 
-			return retArr;
-		}
+pp$8.getToken = function() {
+  this.next();
+  return new Token(this)
+};
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astArrayExpression
-   *
-   * @desc Parses the abstract syntax tree for *Array* Expression
-   *
-   * @param {Object} arrNode - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+  { pp$8[Symbol.iterator] = function() {
+    var this$1 = this;
 
-	}, {
-		key: 'astArrayExpression',
-		value: function astArrayExpression(arrNode, retArr, funcParam) {
-			var arrLen = arrNode.elements.length;
+    return {
+      next: function () {
+        var token = this$1.getToken();
+        return {
+          done: token.type === types.eof,
+          value: token
+        }
+      }
+    }
+  }; }
 
-			retArr.push('new Float32Array(');
-			for (var i = 0; i < arrLen; ++i) {
-				if (i > 0) {
-					retArr.push(', ');
-				}
-				var subNode = arrNode.elements[i];
-				this.astGeneric(subNode, retArr, funcParam);
-			}
-			retArr.push(')');
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
 
-			return retArr;
+pp$8.curContext = function() {
+  return this.context[this.context.length - 1]
+};
 
-			// // Failure, unknown expression
-			// throw this.astErrorOutput(
-			// 	'Unknown  ArrayExpression',
-			// 	arrNode, funcParam
-			//);
-		}
-	}, {
-		key: 'astDebuggerStatement',
-		value: function astDebuggerStatement(arrNode, retArr, funcParam) {
-			retArr.push('debugger;');
-			return retArr;
-		}
-	}], [{
-		key: 'astFunctionPrototype',
-		value: function astFunctionPrototype(ast, retArr, funcParam) {
-			// Setup function return type and name
-			if (funcParam.isRootKernel || funcParam.isSubKernel) {
-				return retArr;
-			}
+// Read a single token, updating the parser object's token-related
+// properties.
 
-			retArr.push(funcParam.returnType);
-			retArr.push(' ');
-			retArr.push(funcParam.functionName);
-			retArr.push('(');
+pp$8.nextToken = function() {
+  var curContext = this.curContext();
+  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
 
-			// Arguments handling
-			for (var i = 0; i < funcParam.paramNames.length; ++i) {
-				if (i > 0) {
-					retArr.push(', ');
-				}
+  this.start = this.pos;
+  if (this.options.locations) { this.startLoc = this.curPosition(); }
+  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
 
-				retArr.push(funcParam.paramTypes[i]);
-				retArr.push(' ');
-				retArr.push('user_');
-				retArr.push(funcParam.paramNames[i]);
-			}
+  if (curContext.override) { return curContext.override(this) }
+  else { this.readToken(this.fullCharCodeAtPos()); }
+};
 
-			retArr.push(');\n');
+pp$8.readToken = function(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+    { return this.readWord() }
 
-			return retArr;
-		}
-	}]);
+  return this.getTokenFromCode(code)
+};
 
-	return CPUFunctionNode;
-}(BaseFunctionNode);
-},{"../../core/utils":74,"../function-node-base":56}],52:[function(require,module,exports){
-'use strict';
+pp$8.fullCharCodeAtPos = function() {
+  var code = this.input.charCodeAt(this.pos);
+  if (code <= 0xd7ff || code >= 0xe000) { return code }
+  var next = this.input.charCodeAt(this.pos + 1);
+  return (code << 10) + next - 0x35fdc00
+};
 
-var utils = require('../../core/utils');
-var kernelRunShortcut = require('../kernel-run-shortcut');
+pp$8.skipBlockComment = function() {
+  var this$1 = this;
 
-module.exports = function (cpuKernel, name) {
-  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: function ' + utils.allPropertiesOf.toString() + ',\n      clone: function ' + utils.clone.toString() + ',\n      /*splitArray: function ' + utils.splitArray.toString() + ',\n      getArgumentType: function ' + utils.getArgumentType.toString() + ',\n      getOutput: function ' + utils.getOutput.toString() + ',\n      dimToTexSize: function ' + utils.dimToTexSize.toString() + ',\n      copyFlatten: function ' + utils.copyFlatten.toString() + ',\n      flatten: function ' + utils.flatten.toString() + ',\n      systemEndianness: \'' + utils.systemEndianness() + '\',\n      initWebGl: function ' + utils.initWebGl.toString() + ',\n      isArray: function ' + utils.isArray.toString() + '*/\n    };\n    class ' + (name || 'Kernel') + ' {\n      constructor() {        \n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = ' + JSON.stringify(cpuKernel.paramNames) + ';\n        this.paramTypes = ' + JSON.stringify(cpuKernel.paramTypes) + ';\n        this.texSize = ' + JSON.stringify(cpuKernel.texSize) + ';\n        this.output = ' + JSON.stringify(cpuKernel.output) + ';\n        this._kernelString = `' + cpuKernel._kernelString + '`;\n        this.output = ' + JSON.stringify(cpuKernel.output) + ';\n\t\t    this.run = function() {\n          this.run = null;\n          this.build();\n          return this.run.apply(this, arguments);\n        }.bind(this);\n        this.thread = {\n          x: 0,\n          y: 0,\n          z: 0\n        };\n      }\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      ' + cpuKernel.build.toString() + '\n      run () { ' + cpuKernel.kernelString + ' }\n      getKernelString() { return this._kernelString; }\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
+  var startLoc = this.options.onComment && this.curPosition();
+  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+  if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
+  this.pos = end + 2;
+  if (this.options.locations) {
+    lineBreakG.lastIndex = start;
+    var match;
+    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+      ++this$1.curLine;
+      this$1.lineStart = match.index + match[0].length;
+    }
+  }
+  if (this.options.onComment)
+    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                           startLoc, this.curPosition()); }
 };
-},{"../../core/utils":74,"../kernel-run-shortcut":58}],53:[function(require,module,exports){
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+pp$8.skipLineComment = function(startSkip) {
+  var this$1 = this;
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  var start = this.pos;
+  var startLoc = this.options.onComment && this.curPosition();
+  var ch = this.input.charCodeAt(this.pos += startSkip);
+  while (this.pos < this.input.length && !isNewLine(ch)) {
+    ch = this$1.input.charCodeAt(++this$1.pos);
+  }
+  if (this.options.onComment)
+    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                           startLoc, this.curPosition()); }
+};
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
 
-var KernelBase = require('../kernel-base');
-var utils = require('../../core/utils');
-var kernelString = require('./kernel-string');
+pp$8.skipSpace = function() {
+  var this$1 = this;
 
-module.exports = function (_KernelBase) {
-	_inherits(CPUKernel, _KernelBase);
+  loop: while (this.pos < this.input.length) {
+    var ch = this$1.input.charCodeAt(this$1.pos);
+    switch (ch) {
+    case 32: case 160: // ' '
+      ++this$1.pos;
+      break
+    case 13:
+      if (this$1.input.charCodeAt(this$1.pos + 1) === 10) {
+        ++this$1.pos;
+      }
+    case 10: case 8232: case 8233:
+      ++this$1.pos;
+      if (this$1.options.locations) {
+        ++this$1.curLine;
+        this$1.lineStart = this$1.pos;
+      }
+      break
+    case 47: // '/'
+      switch (this$1.input.charCodeAt(this$1.pos + 1)) {
+      case 42: // '*'
+        this$1.skipBlockComment();
+        break
+      case 47:
+        this$1.skipLineComment(2);
+        break
+      default:
+        break loop
+      }
+      break
+    default:
+      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+        ++this$1.pos;
+      } else {
+        break loop
+      }
+    }
+  }
+};
 
-	/**
-  * @constructor CPUKernel
-  *
-  * @desc Kernel Implementation for CPU.
-  * 
-  * <p>Instantiates properties to the CPU Kernel.</p>
-  *
-  * @extends KernelBase
-  *
-  * @prop {Object} thread - The thread dimensions, x, y and z
-  * @prop {Object} output - The canvas dimensions
-  * @prop {Object} functionBuilder - Function Builder instance bound to this Kernel
-  * @prop {Function} run - Method to run the kernel
-  *
-  */
-	function CPUKernel(fnString, settings) {
-		_classCallCheck(this, CPUKernel);
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
 
-		var _this = _possibleConstructorReturn(this, (CPUKernel.__proto__ || Object.getPrototypeOf(CPUKernel)).call(this, fnString, settings));
+pp$8.finishToken = function(type, val) {
+  this.end = this.pos;
+  if (this.options.locations) { this.endLoc = this.curPosition(); }
+  var prevType = this.type;
+  this.type = type;
+  this.value = val;
 
-		_this._fnBody = utils.getFunctionBodyFromString(fnString);
-		_this._fn = null;
-		_this.run = null;
-		_this._canvasCtx = null;
-		_this._imageData = null;
-		_this._colorData = null;
-		_this._kernelString = null;
-		_this.thread = {
-			x: 0,
-			y: 0,
-			z: 0
-		};
+  this.updateContext(prevType);
+};
 
-		_this.run = function () {
-			this.run = null;
-			this.build.apply(this, arguments);
-			return this.run.apply(this, arguments);
-		}.bind(_this);
-		return _this;
-	}
+// ### Token reading
 
-	/**
-  * @memberOf CPUKernel#
-  * @function
-  * @name validateOptions
-  *
-  * @desc Validate options related to CPU Kernel, such as 
-  * dimensions size, and auto dimension support.
-  *
-  */
+// This is the function that is called to fetch the next token. It
+// is somewhat obscure, because it works in character codes rather
+// than characters, and because operator parsing has been inlined
+// into it.
+//
+// All in the name of speed.
+//
+pp$8.readToken_dot = function() {
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next >= 48 && next <= 57) { return this.readNumber(true) }
+  var next2 = this.input.charCodeAt(this.pos + 2);
+  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+    this.pos += 3;
+    return this.finishToken(types.ellipsis)
+  } else {
+    ++this.pos;
+    return this.finishToken(types.dot)
+  }
+};
 
+pp$8.readToken_slash = function() { // '/'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.slash, 1)
+};
 
-	_createClass(CPUKernel, [{
-		key: 'validateOptions',
-		value: function validateOptions() {
-			if (!this.output || this.output.length === 0) {
-				if (arguments.length !== 1) {
-					throw 'Auto dimensions only supported for kernels with only one input';
-				}
+pp$8.readToken_mult_modulo_exp = function(code) { // '%*'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  var tokentype = code === 42 ? types.star : types.modulo;
 
-				var argType = utils.getArgumentType(arguments[0]);
-				if (argType === 'Array') {
-					this.output = utils.getDimensions(argType);
-				} else if (argType === 'Texture') {
-					this.output = arguments[0].output;
-				} else {
-					throw 'Auto dimensions not supported for input type: ' + argType;
-				}
-			}
-		}
+  // exponentiation operator ** and **=
+  if (this.options.ecmaVersion >= 7 && code == 42 && next === 42) {
+    ++size;
+    tokentype = types.starstar;
+    next = this.input.charCodeAt(this.pos + 2);
+  }
 
-		/**
-   * @memberOf CPUKernel#
-   * @function
-   * @name build
-   *
-   * @desc Builds the Kernel, by generating the kernel 
-   * string using thread dimensions, and arguments 
-   * supplied to the kernel.
-   *
-   * <p>If the graphical flag is enabled, canvas is used.</p>
-   *
-   */
+  if (next === 61) { return this.finishOp(types.assign, size + 1) }
+  return this.finishOp(tokentype, size)
+};
 
-	}, {
-		key: 'build',
-		value: function build() {
-			this.setupParams(arguments);
-			var threadDim = this.threadDim = utils.clone(this.output);
+pp$8.readToken_pipe_amp = function(code) { // '|&'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+};
 
-			while (threadDim.length < 3) {
-				threadDim.push(1);
-			}
+pp$8.readToken_caret = function() { // '^'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.bitwiseXOR, 1)
+};
 
-			if (this.graphical) {
-				var canvas = this.getCanvas();
-				canvas.width = threadDim[0];
-				canvas.height = threadDim[1];
-				this._canvasCtx = canvas.getContext('2d');
-				this._imageData = this._canvasCtx.createImageData(threadDim[0], threadDim[1]);
-				this._colorData = new Uint8ClampedArray(threadDim[0] * threadDim[1] * 4);
-			}
+pp$8.readToken_plus_min = function(code) { // '+-'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (next == 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 62 &&
+        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
+      // A `-->` line comment
+      this.skipLineComment(3);
+      this.skipSpace();
+      return this.nextToken()
+    }
+    return this.finishOp(types.incDec, 2)
+  }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.plusMin, 1)
+};
 
-			var kernelString = this.getKernelString();
+pp$8.readToken_lt_gt = function(code) { // '<>'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+    return this.finishOp(types.bitShift, size)
+  }
+  if (next == 33 && code == 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 45 &&
+      this.input.charCodeAt(this.pos + 3) == 45) {
+    // `<!--`, an XML-style comment that should be interpreted as a line comment
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken()
+  }
+  if (next === 61) { size = 2; }
+  return this.finishOp(types.relational, size)
+};
 
-			if (this.debug) {
-				console.log('Options:');
-				console.dir(this);
-				console.log('Function output:');
-				console.log(kernelString);
-			}
+pp$8.readToken_eq_excl = function(code) { // '=!'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
+  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+    this.pos += 2;
+    return this.finishToken(types.arrow)
+  }
+  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
+};
 
-			this.kernelString = kernelString;
-			this.run = new Function([], kernelString).bind(this)();
-		}
-	}, {
-		key: 'color',
-		value: function color(r, g, b, a) {
-			if (typeof a === 'undefined') {
-				a = 1;
-			}
+pp$8.getTokenFromCode = function(code) {
+  switch (code) {
+  // The interpretation of a dot depends on whether it is followed
+  // by a digit or another two dots.
+  case 46: // '.'
+    return this.readToken_dot()
 
-			r = Math.floor(r * 255);
-			g = Math.floor(g * 255);
-			b = Math.floor(b * 255);
-			a = Math.floor(a * 255);
-
-			var width = this.output[0];
-			var height = this.output[1];
-
-			var x = this.thread.x;
-			var y = height - this.thread.y - 1;
-
-			var index = x + y * width;
-
-			this._colorData[index * 4 + 0] = r;
-			this._colorData[index * 4 + 1] = g;
-			this._colorData[index * 4 + 2] = b;
-			this._colorData[index * 4 + 3] = a;
-		}
-
-		/**
-   * @memberOf CPUKernel#
-   * @function
-   * @name getKernelString
-   *
-   * @desc Generates kernel string for this kernel program.
-   * 
-   * <p>If sub-kernels are supplied, they are also factored in.
-   * This string can be saved by calling the `toString` method
-   * and then can be reused later.</p>
-   *
-   * @returns {String} result
-   *
-   */
-
-	}, {
-		key: 'getKernelString',
-		value: function getKernelString() {
-			var _this2 = this;
-
-			if (this._kernelString !== null) return this._kernelString;
+  // Punctuation tokens.
+  case 40: ++this.pos; return this.finishToken(types.parenL)
+  case 41: ++this.pos; return this.finishToken(types.parenR)
+  case 59: ++this.pos; return this.finishToken(types.semi)
+  case 44: ++this.pos; return this.finishToken(types.comma)
+  case 91: ++this.pos; return this.finishToken(types.bracketL)
+  case 93: ++this.pos; return this.finishToken(types.bracketR)
+  case 123: ++this.pos; return this.finishToken(types.braceL)
+  case 125: ++this.pos; return this.finishToken(types.braceR)
+  case 58: ++this.pos; return this.finishToken(types.colon)
+  case 63: ++this.pos; return this.finishToken(types.question)
 
-			var builder = this.functionBuilder;
+  case 96: // '`'
+    if (this.options.ecmaVersion < 6) { break }
+    ++this.pos;
+    return this.finishToken(types.backQuote)
 
-			// Thread dim fix (to make compilable)
-			var threadDim = this.threadDim || (this.threadDim = utils.clone(this.output));
-			while (threadDim.length < 3) {
-				threadDim.push(1);
-			}
+  case 48: // '0'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number
+      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number
+    }
 
-			builder.addKernel(this.fnString, {
-				prototypeOnly: false,
-				constants: this.constants,
-				output: this.output,
-				debug: this.debug,
-				loopMaxIterations: this.loopMaxIterations
-			}, this.paramNames, this.paramTypes);
+  // Anything else beginning with a digit is an integer, octal
+  // number, or float.
+  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+    return this.readNumber(false)
 
-			builder.addFunctions(this.functions, {
-				constants: this.constants,
-				output: this.output
-			});
+  // Quotes produce strings.
+  case 34: case 39: // '"', "'"
+    return this.readString(code)
 
-			if (this.subKernels !== null) {
-				this.subKernelOutputTextures = [];
-				this.subKernelOutputVariableNames = [];
-				for (var i = 0; i < this.subKernels.length; i++) {
-					var subKernel = this.subKernels[i];
-					builder.addSubKernel(subKernel, {
-						prototypeOnly: false,
-						constants: this.constants,
-						output: this.output,
-						debug: this.debug,
-						loopMaxIterations: this.loopMaxIterations
-					});
-					this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
-				}
-			} else if (this.subKernelProperties !== null) {
-				this.subKernelOutputVariableNames = [];
-				var _i = 0;
-				for (var p in this.subKernelProperties) {
-					if (!this.subKernelProperties.hasOwnProperty(p)) continue;
-					var _subKernel = this.subKernelProperties[p];
-					builder.addSubKernel(_subKernel);
-					this.subKernelOutputVariableNames.push(_subKernel.name + 'Result');
-					_i++;
-				}
-			}
+  // Operators are parsed inline in tiny state machines. '=' (61) is
+  // often referred to. `finishOp` simply skips the amount of
+  // characters it is given as second argument, and returns a token
+  // of the type given by its first argument.
 
-			var prototypes = builder.getPrototypes();
-			var kernel = prototypes.shift();
-			var kernelString = this._kernelString = '\n\t\tvar LOOP_MAX = ' + this._getLoopMaxString() + ';\n\t\tvar _this = this;\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '  var ' + name + ' = null;\n';
-			}).join('')) + '\n    return function (' + this.paramNames.map(function (paramName) {
-				return 'user_' + paramName;
-			}).join(', ') + ') {\n    var ret = new Array(' + threadDim[2] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '  ' + name + 'Z = new Array(' + threadDim[2] + ');\n';
-			}).join('')) + '\n    for (this.thread.z = 0; this.thread.z < ' + threadDim[2] + '; this.thread.z++) {\n      ret[this.thread.z] = new Array(' + threadDim[1] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '    ' + name + 'Z[this.thread.z] = new Array(' + threadDim[1] + ');\n';
-			}).join('')) + '\n      for (this.thread.y = 0; this.thread.y < ' + threadDim[1] + '; this.thread.y++) {\n        ret[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '      ' + name + 'Z[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n';
-			}).join('')) + '\n        for (this.thread.x = 0; this.thread.x < ' + threadDim[0] + '; this.thread.x++) {\n          var kernelResult;\n          ' + kernel + '\n          ret[this.thread.z][this.thread.y][this.thread.x] = kernelResult;\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '        ' + name + 'Z[this.thread.z][this.thread.y][this.thread.x] = ' + name + ';\n';
-			}).join('')) + '\n          }\n        }\n      }\n      \n      if (this.graphical) {\n        this._imageData.data.set(this._colorData);\n        this._canvasCtx.putImageData(this._imageData, 0, 0);\n        return;\n      }\n      \n      if (this.output.length === 1) {\n        ret = ret[0][0];\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '    ' + name + ' = ' + name + 'Z[0][0];\n';
-			}).join('')) + '\n      \n    } else if (this.output.length === 2) {\n      ret = ret[0];\n      ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
-				return '    ' + name + ' = ' + name + 'Z[0];\n';
-			}).join('')) + '\n    }\n    \n    ' + (this.subKernelOutputVariableNames === null ? 'return ret;\n' : this.subKernels !== null ? 'var result = [\n        ' + this.subKernelOutputVariableNames.map(function (name) {
-				return '' + name;
-			}).join(',\n') + '\n      ];\n      result.result = ret;\n      return result;\n' : 'return {\n        result: ret,\n        ' + Object.keys(this.subKernelProperties).map(function (name, i) {
-				return name + ': ' + _this2.subKernelOutputVariableNames[i];
-			}).join(',\n') + '\n      };') + '\n    ' + (prototypes.length > 0 ? prototypes.join('\n') : '') + '\n    }.bind(this);';
-			return kernelString;
-		}
+  case 47: // '/'
+    return this.readToken_slash()
 
-		/**
-   * @memberOf CPUKernel#
-   * @function
-   * @name toString
-   *
-   * @desc Returns the *pre-compiled* Kernel as a JS Object String, that can be reused.
-   *
-   */
+  case 37: case 42: // '%*'
+    return this.readToken_mult_modulo_exp(code)
 
-	}, {
-		key: 'toString',
-		value: function toString() {
-			return kernelString(this);
-		}
+  case 124: case 38: // '|&'
+    return this.readToken_pipe_amp(code)
 
-		/**
-   * @memberOf CPUKernel#
-   * @function
-   * @name precompileKernelObj
-   *
-   * @desc Precompile the kernel into a single object, 
-   * that can be used for building the execution kernel subsequently.
-   *
-   * @param {Array} argTypes - Array of argument types
-   *     
-   * Return:
-   *     Compiled kernel {Object}
-   *
-   */
+  case 94: // '^'
+    return this.readToken_caret()
 
-	}, {
-		key: 'precompileKernelObj',
-		value: function precompileKernelObj(argTypes) {
+  case 43: case 45: // '+-'
+    return this.readToken_plus_min(code)
 
-			var threadDim = this.threadDim || (this.threadDim = utils.clone(this.output));
+  case 60: case 62: // '<>'
+    return this.readToken_lt_gt(code)
 
-			return {
-				threadDim: threadDim
-			};
-		}
+  case 61: case 33: // '=!'
+    return this.readToken_eq_excl(code)
 
-		/**
-   * @memberOf CPUKernel
-   * @function
-   * @name compileKernel
-   * @static
-   *
-   * @desc Takes a previously precompiled kernel object,
-   * and complete compilation into a full kernel
-   * 
-   * @returns {Function} Compiled kernel
-   *
-   */
+  case 126: // '~'
+    return this.finishOp(types.prefix, 1)
+  }
 
-	}, {
-		key: '_getLoopMaxString',
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
+};
 
+pp$8.finishOp = function(type, size) {
+  var str = this.input.slice(this.pos, this.pos + size);
+  this.pos += size;
+  return this.finishToken(type, str)
+};
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getLoopMaxString
-   *
-   * @desc Get the maximum loop size String.
-   *
-   * @returns {String} result
-   *
-   */
-		value: function _getLoopMaxString() {
-			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + ';\n' : ' 1000;\n';
-		}
-	}], [{
-		key: 'compileKernel',
-		value: function compileKernel(precompileObj) {
+// Parse a regular expression. Some context-awareness is necessary,
+// since a '/' inside a '[]' set does not end the expression.
 
-			// Extract values from precompiled obj
-			var threadDim = precompileObj.threadDim;
+function tryCreateRegexp(src, flags, throwErrorAt, parser) {
+  try {
+    return new RegExp(src, flags)
+  } catch (e) {
+    if (throwErrorAt !== undefined) {
+      if (e instanceof SyntaxError) { parser.raise(throwErrorAt, "Error parsing regular expression: " + e.message); }
+      throw e
+    }
+  }
+}
 
-			// Normalize certain values : For actual build
-			while (threadDim.length < 3) {
-				threadDim.push(1);
-			}
-		}
-	}]);
+var regexpUnicodeSupport = !!tryCreateRegexp("\uffff", "u");
 
-	return CPUKernel;
-}(KernelBase);
-},{"../../core/utils":74,"../kernel-base":57,"./kernel-string":52}],54:[function(require,module,exports){
-'use strict';
+pp$8.readRegexp = function() {
+  var this$1 = this;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+  var escaped, inClass, start = this.pos;
+  for (;;) {
+    if (this$1.pos >= this$1.input.length) { this$1.raise(start, "Unterminated regular expression"); }
+    var ch = this$1.input.charAt(this$1.pos);
+    if (lineBreak.test(ch)) { this$1.raise(start, "Unterminated regular expression"); }
+    if (!escaped) {
+      if (ch === "[") { inClass = true; }
+      else if (ch === "]" && inClass) { inClass = false; }
+      else if (ch === "/" && !inClass) { break }
+      escaped = ch === "\\";
+    } else { escaped = false; }
+    ++this$1.pos;
+  }
+  var content = this.input.slice(start, this.pos);
+  ++this.pos;
+  // Need to use `readWord1` because '\uXXXX' sequences are allowed
+  // here (don't ask).
+  var mods = this.readWord1();
+  var tmp = content, tmpFlags = "";
+  if (mods) {
+    var validFlags = /^[gim]*$/;
+    if (this.options.ecmaVersion >= 6) { validFlags = /^[gimuy]*$/; }
+    if (this.options.ecmaVersion >= 9) { validFlags = /^[gimsuy]*$/; }
+    if (!validFlags.test(mods)) { this.raise(start, "Invalid regular expression flag"); }
+    if (mods.indexOf("u") >= 0) {
+      if (regexpUnicodeSupport) {
+        tmpFlags = "u";
+      } else {
+        // Replace each astral symbol and every Unicode escape sequence that
+        // possibly represents an astral symbol or a paired surrogate with a
+        // single ASCII symbol to avoid throwing on regular expressions that
+        // are only valid in combination with the `/u` flag.
+        // Note: replacing with the ASCII symbol `x` might cause false
+        // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
+        // perfectly valid pattern that is equivalent to `[a-b]`, but it would
+        // be replaced by `[x-b]` which throws an error.
+        tmp = tmp.replace(/\\u\{([0-9a-fA-F]+)\}/g, function (_match, code, offset) {
+          code = Number("0x" + code);
+          if (code > 0x10FFFF) { this$1.raise(start + offset + 3, "Code point out of bounds"); }
+          return "x"
+        });
+        tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
+        tmpFlags = tmpFlags.replace("u", "");
+      }
+    }
+  }
+  // Detect invalid regular expressions.
+  var value = null;
+  // Rhino's regular expression parser is flaky and throws uncatchable exceptions,
+  // so don't do detection if we are running under Rhino
+  if (!isRhino) {
+    tryCreateRegexp(tmp, tmpFlags, start, this);
+    // Get a regular expression object for this pattern-flag pair, or `null` in
+    // case the current environment doesn't support the flags it uses.
+    value = tryCreateRegexp(content, mods);
+  }
+  return this.finishToken(types.regexp, {pattern: content, flags: mods, value: value})
+};
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+// Read an integer in the given radix. Return null if zero digits
+// were read, the integer value otherwise. When `len` is given, this
+// will return `null` unless the integer has exactly `len` digits.
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+pp$8.readInt = function(radix, len) {
+  var this$1 = this;
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  var start = this.pos, total = 0;
+  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    var code = this$1.input.charCodeAt(this$1.pos), val = (void 0);
+    if (code >= 97) { val = code - 97 + 10; } // a
+    else if (code >= 65) { val = code - 65 + 10; } // A
+    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
+    else { val = Infinity; }
+    if (val >= radix) { break }
+    ++this$1.pos;
+    total = total * radix + val;
+  }
+  if (this.pos === start || len != null && this.pos - start !== len) { return null }
 
-var utils = require('../../core/utils');
-var RunnerBase = require('../runner-base');
-var CPUKernel = require('./kernel');
-var CPUFunctionBuilder = require('./function-builder');
+  return total
+};
 
-module.exports = function (_RunnerBase) {
-	_inherits(CPURunner, _RunnerBase);
+pp$8.readRadixNumber = function(radix) {
+  this.pos += 2; // 0x
+  var val = this.readInt(radix);
+  if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+  return this.finishToken(types.num, val)
+};
 
-	/**
-  * @constructor CPURunner
-  *
-  * @desc Instantiates a Runner instance for the kernel.
-  * 
-  * @extends RunnerBase
-  *
-  * @param {Object} settings - Settings to instantiate properties in RunnerBase, with given values
-  *
-  */
+// Read an integer, octal integer, or floating-point number.
 
-	function CPURunner(settings) {
-		_classCallCheck(this, CPURunner);
+pp$8.readNumber = function(startsWithDot) {
+  var start = this.pos;
+  if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
+  if (octal && this.strict) { this.raise(start, "Invalid number"); }
+  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
+  var next = this.input.charCodeAt(this.pos);
+  if (next === 46 && !octal) { // '.'
+    ++this.pos;
+    this.readInt(10);
+    next = this.input.charCodeAt(this.pos);
+  }
+  if ((next === 69 || next === 101) && !octal) { // 'eE'
+    next = this.input.charCodeAt(++this.pos);
+    if (next === 43 || next === 45) { ++this.pos; } // '+-'
+    if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+  }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
 
-		var _this = _possibleConstructorReturn(this, (CPURunner.__proto__ || Object.getPrototypeOf(CPURunner)).call(this, new CPUFunctionBuilder(), settings));
+  var str = this.input.slice(start, this.pos);
+  var val = octal ? parseInt(str, 8) : parseFloat(str);
+  return this.finishToken(types.num, val)
+};
 
-		_this.Kernel = CPUKernel;
-		_this.kernel = null;
-		return _this;
-	}
+// Read a string value, interpreting backslash-escapes.
 
-	/**
-  * @memberOf CPURunner#
-  * @function
-  * @name getMode()
-  *
-  * Return the current mode in which gpu.js is executing.
-  * 
-  * @returns {String} The current mode; "cpu".
-  *
-  */
+pp$8.readCodePoint = function() {
+  var ch = this.input.charCodeAt(this.pos), code;
 
+  if (ch === 123) { // '{'
+    if (this.options.ecmaVersion < 6) { this.unexpected(); }
+    var codePos = ++this.pos;
+    code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
+    ++this.pos;
+    if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
+  } else {
+    code = this.readHexChar(4);
+  }
+  return code
+};
 
-	_createClass(CPURunner, [{
-		key: 'getMode',
-		value: function getMode() {
-			return 'cpu';
-		}
-	}]);
+function codePointToString(code) {
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) { return String.fromCharCode(code) }
+  code -= 0x10000;
+  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
+}
 
-	return CPURunner;
-}(RunnerBase);
-},{"../../core/utils":74,"../runner-base":59,"./function-builder":50,"./kernel":53}],55:[function(require,module,exports){
-'use strict';
+pp$8.readString = function(quote) {
+  var this$1 = this;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+  var out = "", chunkStart = ++this.pos;
+  for (;;) {
+    if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated string constant"); }
+    var ch = this$1.input.charCodeAt(this$1.pos);
+    if (ch === quote) { break }
+    if (ch === 92) { // '\'
+      out += this$1.input.slice(chunkStart, this$1.pos);
+      out += this$1.readEscapedChar(false);
+      chunkStart = this$1.pos;
+    } else {
+      if (isNewLine(ch)) { this$1.raise(this$1.start, "Unterminated string constant"); }
+      ++this$1.pos;
+    }
+  }
+  out += this.input.slice(chunkStart, this.pos++);
+  return this.finishToken(types.string, out)
+};
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+// Reads template string tokens.
 
-module.exports = function () {
+var INVALID_TEMPLATE_ESCAPE_ERROR = {};
 
-	/**
-  * @constructor FunctionBuilderBase
-  *
-  * @desc This handles all the raw state, converted state, etc. of a single function.
-  * [INTERNAL] A collection of functionNodes.
-  * 
-  * @prop {Object} nodeMap - Object map, where nodeMap[function] = new FunctionNode;
-  * @prop {Object} gpu - The current gpu instance bound to this builder
-  * @prop {Object} rootKernel - The root kernel object, contains the paramNames, dimensions etc.
-  * 
-  */
-	function FunctionBuilderBase(gpu) {
-		_classCallCheck(this, FunctionBuilderBase);
+pp$8.tryReadTemplateToken = function() {
+  this.inTemplateElement = true;
+  try {
+    this.readTmplToken();
+  } catch (err) {
+    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+      this.readInvalidTemplateToken();
+    } else {
+      throw err
+    }
+  }
 
-		this.nodeMap = {};
-		this.nativeFunctions = {};
-		this.gpu = gpu;
-		this.rootKernel = null;
-		this.Node = null;
-	}
+  this.inTemplateElement = false;
+};
 
-	_createClass(FunctionBuilderBase, [{
-		key: 'addNativeFunction',
-		value: function addNativeFunction(functionName, glslFunctionString) {
-			this.nativeFunctions[functionName] = glslFunctionString;
-		}
+pp$8.invalidStringToken = function(position, message) {
+  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
+    throw INVALID_TEMPLATE_ESCAPE_ERROR
+  } else {
+    this.raise(position, message);
+  }
+};
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name addFunction
-   *
-   * @desc Instantiates a FunctionNode, and add it to the nodeMap
-   *
-   * @param {String} functionName - Function name to assume, if its null, it attempts to extract from the function
-   * @param {Function} jsFunction - JS Function to do conversion
-   * @param {Object} [options]
-   * @param {String[]|Object} [paramTypes] - Parameter type array, assumes all parameters are 'float' if falsey
-   * @param {String} [returnType] - The return type, assumes 'float' if falsey
-   *
-   */
+pp$8.readTmplToken = function() {
+  var this$1 = this;
 
-	}, {
-		key: 'addFunction',
-		value: function addFunction(functionName, jsFunction, options, paramTypes, returnType) {
-			this.addFunctionNode(new this.Node(functionName, jsFunction, options, paramTypes, returnType).setAddFunction(this.addFunction.bind(this)));
-		}
-	}, {
-		key: 'addFunctions',
-		value: function addFunctions(functions, options) {
-			if (functions) {
-				if (Array.isArray(functions)) {
-					for (var i = 0; i < functions.length; i++) {
-						this.addFunction(null, functions[i], options);
-					}
-				} else {
-					for (var p in functions) {
-						this.addFunction(p, functions[p], options);
-					}
-				}
-			}
-		}
-	}, {
-		key: 'addNativeFunctions',
-		value: function addNativeFunctions(nativeFunctions) {
-			for (var functionName in nativeFunctions) {
-				if (!nativeFunctions.hasOwnProperty(functionName)) continue;
-				this.addNativeFunction(functionName, nativeFunctions[functionName]);
-			}
-		}
+  var out = "", chunkStart = this.pos;
+  for (;;) {
+    if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated template"); }
+    var ch = this$1.input.charCodeAt(this$1.pos);
+    if (ch === 96 || ch === 36 && this$1.input.charCodeAt(this$1.pos + 1) === 123) { // '`', '${'
+      if (this$1.pos === this$1.start && (this$1.type === types.template || this$1.type === types.invalidTemplate)) {
+        if (ch === 36) {
+          this$1.pos += 2;
+          return this$1.finishToken(types.dollarBraceL)
+        } else {
+          ++this$1.pos;
+          return this$1.finishToken(types.backQuote)
+        }
+      }
+      out += this$1.input.slice(chunkStart, this$1.pos);
+      return this$1.finishToken(types.template, out)
+    }
+    if (ch === 92) { // '\'
+      out += this$1.input.slice(chunkStart, this$1.pos);
+      out += this$1.readEscapedChar(true);
+      chunkStart = this$1.pos;
+    } else if (isNewLine(ch)) {
+      out += this$1.input.slice(chunkStart, this$1.pos);
+      ++this$1.pos;
+      switch (ch) {
+      case 13:
+        if (this$1.input.charCodeAt(this$1.pos) === 10) { ++this$1.pos; }
+      case 10:
+        out += "\n";
+        break
+      default:
+        out += String.fromCharCode(ch);
+        break
+      }
+      if (this$1.options.locations) {
+        ++this$1.curLine;
+        this$1.lineStart = this$1.pos;
+      }
+      chunkStart = this$1.pos;
+    } else {
+      ++this$1.pos;
+    }
+  }
+};
+
+// Reads a template token to search for the end, without validating any escape sequences
+pp$8.readInvalidTemplateToken = function() {
+  var this$1 = this;
+
+  for (; this.pos < this.input.length; this.pos++) {
+    switch (this$1.input[this$1.pos]) {
+    case "\\":
+      ++this$1.pos;
+      break
+
+    case "$":
+      if (this$1.input[this$1.pos + 1] !== "{") {
+        break
+      }
+    // falls through
+
+    case "`":
+      return this$1.finishToken(types.invalidTemplate, this$1.input.slice(this$1.start, this$1.pos))
+
+    // no default
+    }
+  }
+  this.raise(this.start, "Unterminated template");
+};
+
+// Used to read escaped characters
+
+pp$8.readEscapedChar = function(inTemplate) {
+  var ch = this.input.charCodeAt(++this.pos);
+  ++this.pos;
+  switch (ch) {
+  case 110: return "\n" // 'n' -> '\n'
+  case 114: return "\r" // 'r' -> '\r'
+  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
+  case 117: return codePointToString(this.readCodePoint()) // 'u'
+  case 116: return "\t" // 't' -> '\t'
+  case 98: return "\b" // 'b' -> '\b'
+  case 118: return "\u000b" // 'v' -> '\u000b'
+  case 102: return "\f" // 'f' -> '\f'
+  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\r\n'
+  case 10: // ' \n'
+    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+    return ""
+  default:
+    if (ch >= 48 && ch <= 55) {
+      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
+      var octal = parseInt(octalStr, 8);
+      if (octal > 255) {
+        octalStr = octalStr.slice(0, -1);
+        octal = parseInt(octalStr, 8);
+      }
+      if (octalStr !== "0" && (this.strict || inTemplate)) {
+        this.invalidStringToken(this.pos - 2, "Octal literal in strict mode");
+      }
+      this.pos += octalStr.length - 1;
+      return String.fromCharCode(octal)
+    }
+    return String.fromCharCode(ch)
+  }
+};
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+pp$8.readHexChar = function(len) {
+  var codePos = this.pos;
+  var n = this.readInt(16, len);
+  if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
+  return n
+};
+
+// Read an identifier, and return it as a string. Sets `this.containsEsc`
+// to whether the word contained a '\u' escape.
+//
+// Incrementally adds only escaped chars, adding other chunks as-is
+// as a micro-optimization.
+
+pp$8.readWord1 = function() {
+  var this$1 = this;
+
+  this.containsEsc = false;
+  var word = "", first = true, chunkStart = this.pos;
+  var astral = this.options.ecmaVersion >= 6;
+  while (this.pos < this.input.length) {
+    var ch = this$1.fullCharCodeAtPos();
+    if (isIdentifierChar(ch, astral)) {
+      this$1.pos += ch <= 0xffff ? 1 : 2;
+    } else if (ch === 92) { // "\"
+      this$1.containsEsc = true;
+      word += this$1.input.slice(chunkStart, this$1.pos);
+      var escStart = this$1.pos;
+      if (this$1.input.charCodeAt(++this$1.pos) != 117) // "u"
+        { this$1.invalidStringToken(this$1.pos, "Expecting Unicode escape sequence \\uXXXX"); }
+      ++this$1.pos;
+      var esc = this$1.readCodePoint();
+      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+        { this$1.invalidStringToken(escStart, "Invalid Unicode escape"); }
+      word += codePointToString(esc);
+      chunkStart = this$1.pos;
+    } else {
+      break
+    }
+    first = false;
+  }
+  return word + this.input.slice(chunkStart, this.pos)
+};
+
+// Read an identifier or keyword token. Will check for reserved
+// words when necessary.
+
+pp$8.readWord = function() {
+  var word = this.readWord1();
+  var type = types.name;
+  if (this.keywords.test(word)) {
+    if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword " + word); }
+    type = keywords$1[word];
+  }
+  return this.finishToken(type, word)
+};
+
+// Acorn is a tiny, fast JavaScript parser written in JavaScript.
+//
+// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
+// various contributors and released under an MIT license.
+//
+// Git repositories for Acorn are available at
+//
+//     http://marijnhaverbeke.nl/git/acorn
+//     https://github.com/acornjs/acorn.git
+//
+// Please use the [github bug tracker][ghbt] to report issues.
+//
+// [ghbt]: https://github.com/acornjs/acorn/issues
+//
+// This file defines the main parser interface. The library also comes
+// with a [error-tolerant parser][dammit] and an
+// [abstract syntax tree walker][walk], defined in other files.
+//
+// [dammit]: acorn_loose.js
+// [walk]: util/walk.js
+
+var version = "5.3.0";
+
+// The main exported interface (under `self.acorn` when in the
+// browser) is a `parse` function that takes a code string and
+// returns an abstract syntax tree as specified by [Mozilla parser
+// API][api].
+//
+// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+function parse(input, options) {
+  return new Parser(options, input).parse()
+}
+
+// This function tries to parse a single expression at a given
+// offset in a string. Useful for parsing mixed-language formats
+// that embed JavaScript expressions.
+
+function parseExpressionAt(input, pos, options) {
+  var p = new Parser(options, input, pos);
+  p.nextToken();
+  return p.parseExpression()
+}
+
+// Acorn is organized as a tokenizer and a recursive-descent parser.
+// The `tokenizer` export provides an interface to the tokenizer.
+
+function tokenizer(input, options) {
+  return new Parser(options, input)
+}
+
+// This is a terrible kludge to support the existing, pre-ES6
+// interface where the loose parser module retroactively adds exports
+// to this module.
+ // eslint-disable-line camelcase
+function addLooseExports(parse, Parser$$1, plugins$$1) {
+  exports.parse_dammit = parse; // eslint-disable-line camelcase
+  exports.LooseParser = Parser$$1;
+  exports.pluginsLoose = plugins$$1;
+}
+
+exports.version = version;
+exports.parse = parse;
+exports.parseExpressionAt = parseExpressionAt;
+exports.tokenizer = tokenizer;
+exports.addLooseExports = addLooseExports;
+exports.Parser = Parser;
+exports.plugins = plugins;
+exports.defaultOptions = defaultOptions;
+exports.Position = Position;
+exports.SourceLocation = SourceLocation;
+exports.getLineInfo = getLineInfo;
+exports.Node = Node;
+exports.TokenType = TokenType;
+exports.tokTypes = types;
+exports.keywordTypes = keywords$1;
+exports.TokContext = TokContext;
+exports.tokContexts = types$1;
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierStart = isIdentifierStart;
+exports.Token = Token;
+exports.isNewLine = isNewLine;
+exports.lineBreak = lineBreak;
+exports.lineBreakG = lineBreakG;
+exports.nonASCIIwhitespace = nonASCIIwhitespace;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],46:[function(require,module,exports){
+'use strict'
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i]
+  revLookup[code.charCodeAt(i)] = i
+}
+
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function placeHoldersCount (b64) {
+  var len = b64.length
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4')
+  }
+
+  // the number of equal signs (place holders)
+  // if there are two placeholders, than the two characters before it
+  // represent one byte
+  // if there is only one, then the three characters before it represent 2 bytes
+  // this is just a cheap hack to not do indexOf twice
+  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
+}
+
+function byteLength (b64) {
+  // base64 is 4/3 + up to two characters of the original data
+  return (b64.length * 3 / 4) - placeHoldersCount(b64)
+}
+
+function toByteArray (b64) {
+  var i, l, tmp, placeHolders, arr
+  var len = b64.length
+  placeHolders = placeHoldersCount(b64)
+
+  arr = new Arr((len * 3 / 4) - placeHolders)
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  l = placeHolders > 0 ? len - 4 : len
+
+  var L = 0
+
+  for (i = 0; i < l; i += 4) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
+    arr[L++] = (tmp >> 16) & 0xFF
+    arr[L++] = (tmp >> 8) & 0xFF
+    arr[L++] = tmp & 0xFF
+  }
+
+  if (placeHolders === 2) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
+    arr[L++] = tmp & 0xFF
+  } else if (placeHolders === 1) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
+    arr[L++] = (tmp >> 8) & 0xFF
+    arr[L++] = tmp & 0xFF
+  }
+
+  return arr
+}
+
+function tripletToBase64 (num) {
+  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+  var tmp
+  var output = []
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+    output.push(tripletToBase64(tmp))
+  }
+  return output.join('')
+}
+
+function fromByteArray (uint8) {
+  var tmp
+  var len = uint8.length
+  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+  var output = ''
+  var parts = []
+  var maxChunkLength = 16383 // must be multiple of 3
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1]
+    output += lookup[tmp >> 2]
+    output += lookup[(tmp << 4) & 0x3F]
+    output += '=='
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
+    output += lookup[tmp >> 10]
+    output += lookup[(tmp >> 4) & 0x3F]
+    output += lookup[(tmp << 2) & 0x3F]
+    output += '='
+  }
+
+  parts.push(output)
+
+  return parts.join('')
+}
+
+},{}],47:[function(require,module,exports){
+
+},{}],48:[function(require,module,exports){
+(function (global){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+var isArray = require('isarray')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ *     incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+  ? global.TYPED_ARRAY_SUPPORT
+  : typedArraySupport()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+  try {
+    var arr = new Uint8Array(1)
+    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+    return arr.foo() === 42 && // typed array instances can be augmented
+        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+  } catch (e) {
+    return false
+  }
+}
+
+function kMaxLength () {
+  return Buffer.TYPED_ARRAY_SUPPORT
+    ? 0x7fffffff
+    : 0x3fffffff
+}
+
+function createBuffer (that, length) {
+  if (kMaxLength() < length) {
+    throw new RangeError('Invalid typed array length')
+  }
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = new Uint8Array(length)
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    if (that === null) {
+      that = new Buffer(length)
+    }
+    that.length = length
+  }
+
+  return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+    return new Buffer(arg, encodingOrOffset, length)
+  }
+
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new Error(
+        'If encoding is specified then the first argument must be a string'
+      )
+    }
+    return allocUnsafe(this, arg)
+  }
+  return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+  arr.__proto__ = Buffer.prototype
+  return arr
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name addFunctionNode
-   *
-   * @desc Add the function node directly
-   *
-   * @param {functionNode} inNode - functionNode to add
-   *
-   */
+function from (that, value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
 
-	}, {
-		key: 'addFunctionNode',
-		value: function addFunctionNode(inNode) {
-			this.nodeMap[inNode.functionName] = inNode;
-			if (inNode.isRootKernel) {
-				this.rootKernel = inNode;
-			}
-		}
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    return fromArrayBuffer(that, value, encodingOrOffset, length)
+  }
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name traceFunctionCalls
-   *
-   * @desc Trace all the depending functions being called, from a single function
-   *
-   * This allow for 'unneeded' functions to be automatically optimized out.
-   * Note that the 0-index, is the starting function trace.
-   *
-   * @param {String} functionName - Function name to trace from, default to 'kernel'
-   * @param {String[]} retList - Returning list of function names that is traced. Including itself.
-   * @param {Object} [parent] - Parent node
-   *
-   * @returns {String[]}  Returning list of function names that is traced. Including itself.
-   */
+  if (typeof value === 'string') {
+    return fromString(that, value, encodingOrOffset)
+  }
 
-	}, {
-		key: 'traceFunctionCalls',
-		value: function traceFunctionCalls(functionName, retList, parent) {
-			functionName = functionName || 'kernel';
-			retList = retList || [];
+  return fromObject(that, value)
+}
 
-			var fNode = this.nodeMap[functionName];
-			if (fNode) {
-				// Check if function already exists
-				var functionIndex = retList.indexOf(functionName);
-				if (functionIndex === -1) {
-					retList.push(functionName);
-					if (parent) {
-						fNode.parent = parent;
-					}
-					fNode.getFunctionString(); //ensure JS trace is done
-					for (var i = 0; i < fNode.calledFunctions.length; ++i) {
-						this.traceFunctionCalls(fNode.calledFunctions[i], retList, fNode);
-					}
-				} else {
-					/**
-      * https://github.com/gpujs/gpu.js/issues/207
-      * if dependent function is already in the list, because a function depends on it, and because it has
-      * already been traced, we know that we must move the dependent function to the end of the the retList.
-      * */
-					var dependantFunctionName = retList.splice(functionIndex, 1)[0];
-					retList.push(dependantFunctionName);
-				}
-			}
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(null, value, encodingOrOffset, length)
+}
 
-			if (this.nativeFunctions[functionName]) {
-				if (retList.indexOf(functionName) >= 0) {
-					// Does nothing if already traced
-				} else {
-					retList.push(functionName);
-				}
-			}
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+  Buffer.prototype.__proto__ = Uint8Array.prototype
+  Buffer.__proto__ = Uint8Array
+  if (typeof Symbol !== 'undefined' && Symbol.species &&
+      Buffer[Symbol.species] === Buffer) {
+    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+    Object.defineProperty(Buffer, Symbol.species, {
+      value: null,
+      configurable: true
+    })
+  }
+}
 
-			return retList;
-		}
+function assertSize (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be a number')
+  } else if (size < 0) {
+    throw new RangeError('"size" argument must not be negative')
+  }
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name addKernel
-   *
-   * @desc Add a new kernel to this instance
-   *
-   * @param {String} fnString - Kernel function as a String
-   * @param {Object} options - Settings object to set constants, debug mode, etc.
-   * @param {Array} paramNames - Parameters of the kernel
-   * @param {Array} paramTypes - Types of the parameters
-   *
-   *
-   * @returns {Object} The inserted kernel as a Kernel Node
-   *
-   */
+function alloc (that, size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(that, size)
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpretted as a start offset.
+    return typeof encoding === 'string'
+      ? createBuffer(that, size).fill(fill, encoding)
+      : createBuffer(that, size).fill(fill)
+  }
+  return createBuffer(that, size)
+}
 
-	}, {
-		key: 'addKernel',
-		value: function addKernel(fnString, options, paramNames, paramTypes) {
-			var kernelNode = new this.Node('kernel', fnString, options, paramTypes);
-			kernelNode.setAddFunction(this.addFunction.bind(this));
-			kernelNode.paramNames = paramNames;
-			kernelNode.paramTypes = paramTypes;
-			kernelNode.isRootKernel = true;
-			this.addFunctionNode(kernelNode);
-			return kernelNode;
-		}
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(null, size, fill, encoding)
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name addSubKernel
-   *
-   * @desc Add a new sub-kernel to the current kernel instance
-   *
-   * @param {Function} jsFunction - Sub-kernel function (JavaScript)
-   * @param {Object} options - Settings object to set constants, debug mode, etc.
-   * @param {Array} paramNames - Parameters of the sub-kernel
-   * @param {Array} returnType - Return type of the subKernel
-   *
-   * @returns {Object} The inserted sub-kernel as a Kernel Node
-   *
-   */
+function allocUnsafe (that, size) {
+  assertSize(size)
+  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+    for (var i = 0; i < size; ++i) {
+      that[i] = 0
+    }
+  }
+  return that
+}
 
-	}, {
-		key: 'addSubKernel',
-		value: function addSubKernel(jsFunction, options, paramTypes, returnType) {
-			var kernelNode = new this.Node(null, jsFunction, options, paramTypes, returnType);
-			kernelNode.setAddFunction(this.addFunction.bind(this));
-			kernelNode.isSubKernel = true;
-			this.addFunctionNode(kernelNode);
-			return kernelNode;
-		}
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(null, size)
+}
 
-		/**
-   * @memberOf CPUFunctionBuilder#
-   * @name getPrototypeString
-   * @function
-   *
-   * @desc Return the string for a function
-   *
-   * @param {String} functionName - Function name to trace from. If null, it returns the WHOLE builder stack
-   *
-   * @returns {String} The full string, of all the various functions. Trace optimized if functionName given
-   *
-   */
+function fromString (that, string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
 
-	}, {
-		key: 'getPrototypeString',
-		value: function getPrototypeString(functionName) {
-			return this.getPrototypes(functionName).join('\n');
-		}
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
 
-		/**
-   * @memberOf CPUFunctionBuilder#
-   * @name getPrototypeString
-   * @function
-   *
-   * @desc Return the string for a function
-   *
-   * @param {String} [functionName] - Function name to trace from. If null, it returns the WHOLE builder stack
-   *
-   * @returns {Array} The full string, of all the various functions. Trace optimized if functionName given
-   *
-   */
+  var length = byteLength(string, encoding) | 0
+  that = createBuffer(that, length)
+
+  var actual = that.write(string, encoding)
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    that = that.slice(0, actual)
+  }
 
-	}, {
-		key: 'getPrototypes',
-		value: function getPrototypes(functionName) {
-			this.rootKernel.generate();
-			if (functionName) {
-				return this.getPrototypesFromFunctionNames(this.traceFunctionCalls(functionName, []).reverse());
-			}
-			return this.getPrototypesFromFunctionNames(Object.keys(this.nodeMap));
-		}
+  return that
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name getStringFromFunctionNames
-   *
-   * @desc Get string from function names
-   *
-   * @param {String[]} functionList - List of function to build string
-   *
-   * @returns {String} The string, of all the various functions. Trace optimized if functionName given
-   *
-   */
+function fromArrayLike (that, array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  that = createBuffer(that, length)
+  for (var i = 0; i < length; i += 1) {
+    that[i] = array[i] & 255
+  }
+  return that
+}
 
-	}, {
-		key: 'getStringFromFunctionNames',
-		value: function getStringFromFunctionNames(functionList) {
-			var ret = [];
-			for (var i = 0; i < functionList.length; ++i) {
-				var node = this.nodeMap[functionList[i]];
-				if (node) {
-					ret.push(this.nodeMap[functionList[i]].getFunctionString());
-				}
-			}
-			return ret.join('\n');
-		}
+function fromArrayBuffer (that, array, byteOffset, length) {
+  array.byteLength // this throws if `array` is not a valid ArrayBuffer
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name getPrototypeStringFromFunctionNames
-   *
-   * @desc Return string of all functions converted
-   *
-   * @param {String[]} functionList - List of function names to build the string.
-   * @param {Object} [opt - Settings object passed to functionNode. See functionNode for more details.
-   *
-   * @returns {Array} Prototypes of all functions converted
-   *
-   */
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('\'offset\' is out of bounds')
+  }
 
-	}, {
-		key: 'getPrototypesFromFunctionNames',
-		value: function getPrototypesFromFunctionNames(functionList, opt) {
-			var ret = [];
-			for (var i = 0; i < functionList.length; ++i) {
-				var functionName = functionList[i];
-				var node = this.nodeMap[functionName];
-				if (node) {
-					ret.push(node.getFunctionPrototypeString(opt));
-				} else if (this.nativeFunctions[functionName]) {
-					ret.push(this.nativeFunctions[functionName]);
-				}
-			}
-			return ret;
-		}
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('\'length\' is out of bounds')
+  }
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name getPrototypeStringFromFunctionNames
-   *
-   * @desc Return string of all functions converted
-   *
-   * @param {String[]} functionList - List of function names to build the string.
-   * @param {Object} opt - Settings object passed to functionNode. See functionNode for more details.
-   *
-   * @returns {String} Prototype string of all functions converted
-   *
-   */
+  if (byteOffset === undefined && length === undefined) {
+    array = new Uint8Array(array)
+  } else if (length === undefined) {
+    array = new Uint8Array(array, byteOffset)
+  } else {
+    array = new Uint8Array(array, byteOffset, length)
+  }
 
-	}, {
-		key: 'getPrototypeStringFromFunctionNames',
-		value: function getPrototypeStringFromFunctionNames(functionList, opt) {
-			return this.getPrototypesFromFunctionNames(functionList, opt).toString();
-		}
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = array
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    that = fromArrayLike(that, array)
+  }
+  return that
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name getString
-   *
-   * Get string for a particular function name
-   *
-   * @param {String} functionName - Function name to trace from. If null, it returns the WHOLE builder stack
-   *
-   * @returns {String} The string, of all the various functions. Trace optimized if functionName given
-   *
-   */
+function fromObject (that, obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    that = createBuffer(that, len)
 
-	}, {
-		key: 'getString',
-		value: function getString(functionName, opt) {
-			if (opt === undefined) {
-				opt = {};
-			}
+    if (that.length === 0) {
+      return that
+    }
 
-			if (functionName) {
-				return this.getStringFromFunctionNames(this.traceFunctionCalls(functionName, [], opt).reverse(), opt);
-			}
-			return this.getStringFromFunctionNames(Object.keys(this.nodeMap), opt);
-		}
-	}, {
-		key: 'polyfillStandardFunctions',
-		value: function polyfillStandardFunctions() {
-			throw new Error('polyfillStandardFunctions not defined on base function builder');
-		}
-	}]);
+    obj.copy(that, 0, 0, len)
+    return that
+  }
 
-	return FunctionBuilderBase;
-}();
-},{}],56:[function(require,module,exports){
-'use strict';
+  if (obj) {
+    if ((typeof ArrayBuffer !== 'undefined' &&
+        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+      if (typeof obj.length !== 'number' || isnan(obj.length)) {
+        return createBuffer(that, 0)
+      }
+      return fromArrayLike(that, obj)
+    }
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+    if (obj.type === 'Buffer' && isArray(obj.data)) {
+      return fromArrayLike(that, obj.data)
+    }
+  }
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function checked (length) {
+  // Note: cannot use `length < kMaxLength()` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= kMaxLength()) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
+  }
+  return length | 0
+}
 
-var utils = require('../core/utils');
-var acorn = require('acorn');
+function SlowBuffer (length) {
+  if (+length != length) { // eslint-disable-line eqeqeq
+    length = 0
+  }
+  return Buffer.alloc(+length)
+}
 
-module.exports = function () {
+Buffer.isBuffer = function isBuffer (b) {
+  return !!(b != null && b._isBuffer)
+}
 
-	/**
-  * @constructor FunctionNodeBase
-  * 
-  * @desc Represents a single function, inside JS, webGL, or openGL.
-  * 
-  * <p>This handles all the raw state, converted state, etc. Of a single function.</p>
-  * 
-  * @prop {String} functionName - Name of the function
-  * @prop {Function} jsFunction - The JS Function the node represents
-  * @prop {String} jsFunctionString - jsFunction.toString()
-  * @prop {String[]} paramNames - Parameter names of the function
-  * @prop {String[]} paramTypes - Shader land parameters type assumption
-  * @prop {Boolean} isRootKernel - Special indicator, for kernel function
-  * @prop {String} webglFunctionString - webgl converted function string
-  * @prop {String} openglFunctionString - opengl converted function string
-  * @prop {String[]} calledFunctions - List of all the functions called
-  * @prop {String[]} initVariables - List of variables initialized in the function
-  * @prop {String[]} readVariables - List of variables read operations occur
-  * @prop {String[]} writeVariables - List of variables write operations occur
-  * 
-  * @param {GPU} gpu - The GPU instance
-  * @param {String} functionName - Function name to assume, if its null, it attempts to extract from the function
-  * @param {Function|String} jsFunction - JS Function to do conversion
-  * @param {String[]|Object} paramTypes - Parameter type array, assumes all parameters are 'float' if null
-  * @param {String} returnType - The return type, assumes 'float' if null
-  *
-  */
-	function BaseFunctionNode(functionName, jsFunction, options, paramTypes, returnType) {
-		_classCallCheck(this, BaseFunctionNode);
+Buffer.compare = function compare (a, b) {
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError('Arguments must be Buffers')
+  }
 
-		//
-		// Internal vars setup
-		//
-		this.calledFunctions = [];
-		this.calledFunctionsArguments = {};
-		this.initVariables = [];
-		this.readVariables = [];
-		this.writeVariables = [];
-		this.addFunction = null;
-		this.isRootKernel = false;
-		this.isSubKernel = false;
-		this.parent = null;
-		this.debug = null;
-		this.prototypeOnly = null;
-		this.constants = null;
-		this.output = null;
+  if (a === b) return 0
+
+  var x = a.length
+  var y = b.length
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i]
+      y = b[i]
+      break
+    }
+  }
 
-		if (options) {
-			if (options.hasOwnProperty('debug')) {
-				this.debug = options.debug;
-			}
-			if (options.hasOwnProperty('prototypeOnly')) {
-				this.prototypeOnly = options.prototypeOnly;
-			}
-			if (options.hasOwnProperty('constants')) {
-				this.constants = options.constants;
-			}
-			if (options.hasOwnProperty('output')) {
-				this.output = options.output;
-			}
-			if (options.hasOwnProperty('loopMaxIterations')) {
-				this.loopMaxIterations = options.loopMaxIterations;
-			}
-		}
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
 
-		//
-		// Missing jsFunction object exception
-		//
-		if (!jsFunction) {
-			throw 'jsFunction, parameter is missing';
-		}
+Buffer.isEncoding = function isEncoding (encoding) {
+  switch (String(encoding).toLowerCase()) {
+    case 'hex':
+    case 'utf8':
+    case 'utf-8':
+    case 'ascii':
+    case 'latin1':
+    case 'binary':
+    case 'base64':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true
+    default:
+      return false
+  }
+}
 
-		//
-		// Setup jsFunction and its string property + validate them
-		//
-		this.jsFunctionString = jsFunction.toString();
-		if (!utils.isFunctionString(this.jsFunctionString)) {
-			console.error('jsFunction, to string conversion check failed: not a function?', this.jsFunctionString);
-			throw 'jsFunction, to string conversion check failed: not a function?';
-		}
+Buffer.concat = function concat (list, length) {
+  if (!isArray(list)) {
+    throw new TypeError('"list" argument must be an Array of Buffers')
+  }
 
-		if (!utils.isFunction(jsFunction)) {
-			//throw 'jsFunction, is not a valid JS Function';
-			this.jsFunction = null;
-		} else {
-			this.jsFunction = jsFunction;
-		}
+  if (list.length === 0) {
+    return Buffer.alloc(0)
+  }
 
-		//
-		// Setup the function name property
-		//
-		this.functionName = functionName || jsFunction && jsFunction.name || utils.getFunctionNameFromString(this.jsFunctionString);
+  var i
+  if (length === undefined) {
+    length = 0
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length
+    }
+  }
 
-		if (!this.functionName) {
-			throw 'jsFunction, missing name argument or value';
-		}
+  var buffer = Buffer.allocUnsafe(length)
+  var pos = 0
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i]
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers')
+    }
+    buf.copy(buffer, pos)
+    pos += buf.length
+  }
+  return buffer
+}
 
-		//
-		// Extract parameter name, and its argument types
-		//
-		this.paramNames = utils.getParamNamesFromString(this.jsFunctionString);
-		if (paramTypes) {
-			if (Array.isArray(paramTypes)) {
-				if (paramTypes.length !== this.paramNames.length) {
-					throw 'Invalid argument type array length, against function length -> (' + paramTypes.length + ',' + this.paramNames.length + ')';
-				}
-				this.paramTypes = paramTypes;
-			} else if ((typeof paramTypes === 'undefined' ? 'undefined' : _typeof(paramTypes)) === 'object') {
-				var paramVariableNames = Object.keys(paramTypes);
-				if (paramTypes.hasOwnProperty('returns')) {
-					this.returnType = paramTypes.returns;
-					paramVariableNames.splice(paramVariableNames.indexOf('returns'), 1);
-				}
-				if (paramVariableNames.length > 0 && paramVariableNames.length !== this.paramNames.length) {
-					throw 'Invalid argument type array length, against function length -> (' + paramVariableNames.length + ',' + this.paramNames.length + ')';
-				} else {
-					this.paramTypes = this.paramNames.map(function (key) {
-						if (paramTypes.hasOwnProperty(key)) {
-							return paramTypes[key];
-						} else {
-							return 'float';
-						}
-					});
-				}
-			}
-		} else {
-			this.paramTypes = [];
-			//TODO: Remove when we have proper type detection
-			// for (let a = 0; a < this.paramNames.length; ++a) {
-			// 	this.paramTypes.push();
-			// }
-		}
+function byteLength (string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length
+  }
+  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+    return string.byteLength
+  }
+  if (typeof string !== 'string') {
+    string = '' + string
+  }
 
-		//
-		// Return type handling
-		//
-		if (!this.returnType) {
-			this.returnType = returnType || 'float';
-		}
-	}
+  var len = string.length
+  if (len === 0) return 0
 
-	_createClass(BaseFunctionNode, [{
-		key: 'isIdentifierConstant',
-		value: function isIdentifierConstant(paramName) {
-			if (!this.constants) return false;
-			return this.constants.hasOwnProperty(paramName);
-		}
-	}, {
-		key: 'setAddFunction',
-		value: function setAddFunction(fn) {
-			this.addFunction = fn;
-			return this;
-		}
-		/**
-   * 
-   * Core Functions
-   * 
-   */
+  // Use a for loop to avoid recursion
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+        return len
+      case 'utf8':
+      case 'utf-8':
+      case undefined:
+        return utf8ToBytes(string).length
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return len * 2
+      case 'hex':
+        return len >>> 1
+      case 'base64':
+        return base64ToBytes(string).length
+      default:
+        if (loweredCase) return utf8ToBytes(string).length // assume utf8
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+Buffer.byteLength = byteLength
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name getJSFunction
-   *
-   * @desc Gets and return the stored JS Function.
-   * Note: that this internally eval the function, if only the string was provided on construction
-   *
-   * @returns {Function} The function object
-   *
-   */
+function slowToString (encoding, start, end) {
+  var loweredCase = false
 
-	}, {
-		key: 'getJsFunction',
-		value: function getJsFunction() {
-			if (this.jsFunction) {
-				return this.jsFunction;
-			}
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
 
-			if (this.jsFunctionString) {
-				this.jsFunction = eval(this.jsFunctionString);
-				return this.jsFunction;
-			}
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return ''
+  }
 
-			throw 'Missing jsFunction, and jsFunctionString parameter';
-		}
+  if (end === undefined || end > this.length) {
+    end = this.length
+  }
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name astMemberExpressionUnroll
-   * @desc Parses the abstract syntax tree for binary expression.
-   *
-   * <p>Utility function for astCallExpression.</p>
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {String} the function namespace call, unrolled
-   */
+  if (end <= 0) {
+    return ''
+  }
+
+  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0
+  start >>>= 0
+
+  if (end <= start) {
+    return ''
+  }
 
-	}, {
-		key: 'astMemberExpressionUnroll',
-		value: function astMemberExpressionUnroll(ast, funcParam) {
-			if (ast.type === 'Identifier') {
-				return ast.name;
-			} else if (ast.type === 'ThisExpression') {
-				return 'this';
-			}
+  if (!encoding) encoding = 'utf8'
 
-			if (ast.type === 'MemberExpression') {
-				if (ast.object && ast.property) {
-					//babel sniffing
-					if (ast.object.hasOwnProperty('name') && ast.object.name[0] === '_') {
-						return this.astMemberExpressionUnroll(ast.property, funcParam);
-					}
+  while (true) {
+    switch (encoding) {
+      case 'hex':
+        return hexSlice(this, start, end)
 
-					return this.astMemberExpressionUnroll(ast.object, funcParam) + '.' + this.astMemberExpressionUnroll(ast.property, funcParam);
-				}
-			}
+      case 'utf8':
+      case 'utf-8':
+        return utf8Slice(this, start, end)
 
-			//babel sniffing
-			if (ast.hasOwnProperty('expressions')) {
-				var firstExpression = ast.expressions[0];
-				if (firstExpression.type === 'Literal' && firstExpression.value === 0 && ast.expressions.length === 2) {
-					return this.astMemberExpressionUnroll(ast.expressions[1]);
-				}
-			}
+      case 'ascii':
+        return asciiSlice(this, start, end)
 
-			// Failure, unknown expression
-			throw this.astErrorOutput('Unknown CallExpression_unroll', ast, funcParam);
-		}
+      case 'latin1':
+      case 'binary':
+        return latin1Slice(this, start, end)
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name getJsAST
-   *
-   * @desc Parses the class function JS, and returns its Abstract Syntax Tree object.
-   *
-   * This is used internally to convert to shader code
-   *
-   * @param {JISONParser} inParser - Parser to use, assumes in scope 'parser' if null
-   *
-   * @returns {ASTObject} The function AST Object, note that result is cached under this.jsFunctionAST;
-   *
-   */
+      case 'base64':
+        return base64Slice(this, start, end)
 
-	}, {
-		key: 'getJsAST',
-		value: function getJsAST(inParser) {
-			if (this.jsFunctionAST) {
-				return this.jsFunctionAST;
-			}
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return utf16leSlice(this, start, end)
 
-			inParser = inParser || acorn;
-			if (inParser === null) {
-				throw 'Missing JS to AST parser';
-			}
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = (encoding + '').toLowerCase()
+        loweredCase = true
+    }
+  }
+}
 
-			var ast = inParser.parse('var ' + this.functionName + ' = ' + this.jsFunctionString + ';', {
-				locations: true
-			});
-			if (ast === null) {
-				throw 'Failed to parse JS code';
-			}
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
 
-			// take out the function object, outside the var declarations
-			var funcAST = ast.body[0].declarations[0].init;
-			this.jsFunctionAST = funcAST;
+function swap (b, n, m) {
+  var i = b[n]
+  b[n] = b[m]
+  b[m] = i
+}
 
-			return funcAST;
-		}
+Buffer.prototype.swap16 = function swap16 () {
+  var len = this.length
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits')
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1)
+  }
+  return this
+}
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name getFunctionString
-   *
-   * @desc Returns the converted webgl shader function equivalent of the JS function
-   *
-   * @returns {String} webgl function string, result is cached under this.webGlFunctionString
-   *
-   */
+Buffer.prototype.swap32 = function swap32 () {
+  var len = this.length
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits')
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3)
+    swap(this, i + 1, i + 2)
+  }
+  return this
+}
 
-	}, {
-		key: 'getFunctionString',
-		value: function getFunctionString() {
-			this.generate();
-			return this.functionString;
-		}
+Buffer.prototype.swap64 = function swap64 () {
+  var len = this.length
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits')
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7)
+    swap(this, i + 1, i + 6)
+    swap(this, i + 2, i + 5)
+    swap(this, i + 3, i + 4)
+  }
+  return this
+}
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name setFunctionString
-   *
-   * @desc Set the functionString value, overwriting it
-   *
-   * @param {String} functionString - Shader code string, representing the function
-   *
-   */
+Buffer.prototype.toString = function toString () {
+  var length = this.length | 0
+  if (length === 0) return ''
+  if (arguments.length === 0) return utf8Slice(this, 0, length)
+  return slowToString.apply(this, arguments)
+}
 
-	}, {
-		key: 'setFunctionString',
-		value: function setFunctionString(functionString) {
-			this.functionString = functionString;
-		}
+Buffer.prototype.equals = function equals (b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+  if (this === b) return true
+  return Buffer.compare(this, b) === 0
+}
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name getParamType
-   *
-   * @desc Return the type of parameter sent to subKernel/Kernel.
-   *
-   * @param {String} paramName - Name of the parameter
-   *
-   * @returns {String} Type of the parameter
-   *
-   */
+Buffer.prototype.inspect = function inspect () {
+  var str = ''
+  var max = exports.INSPECT_MAX_BYTES
+  if (this.length > 0) {
+    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+    if (this.length > max) str += ' ... '
+  }
+  return '<Buffer ' + str + '>'
+}
 
-	}, {
-		key: 'getParamType',
-		value: function getParamType(paramName) {
-			var paramIndex = this.paramNames.indexOf(paramName);
-			if (paramIndex === -1) return null;
-			if (!this.parent) return null;
-			if (this.paramTypes[paramIndex]) return this.paramTypes[paramIndex];
-			var calledFunctionArguments = this.parent.calledFunctionsArguments[this.functionName];
-			for (var i = 0; i < calledFunctionArguments.length; i++) {
-				var calledFunctionArgument = calledFunctionArguments[i];
-				if (calledFunctionArgument[paramIndex] !== null) {
-					return this.paramTypes[paramIndex] = calledFunctionArgument[paramIndex].type;
-				}
-			}
-			return null;
-		}
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError('Argument must be a Buffer')
+  }
 
-		/**
-   * @memberOf FunctionNodeBase#
-   * @function
-   * @name getUserParamName
-   *
-   * @desc Return the name of the *user parameter*(subKernel parameter) corresponding 
-   * to the parameter supplied to the kernel
-   *
-   * @param {String} paramName - Name of the parameter
-   *
-   * @returns {String} Name of the parameter
-   *
-   */
+  if (start === undefined) {
+    start = 0
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0
+  }
+  if (thisStart === undefined) {
+    thisStart = 0
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index')
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0
+  }
+  if (thisStart >= thisEnd) {
+    return -1
+  }
+  if (start >= end) {
+    return 1
+  }
 
-	}, {
-		key: 'getUserParamName',
-		value: function getUserParamName(paramName) {
-			var paramIndex = this.paramNames.indexOf(paramName);
-			if (paramIndex === -1) return null;
-			if (!this.parent) return null;
-			var calledFunctionArguments = this.parent.calledFunctionsArguments[this.functionName];
-			for (var i = 0; i < calledFunctionArguments.length; i++) {
-				var calledFunctionArgument = calledFunctionArguments[i];
-				if (calledFunctionArgument[paramIndex] !== null) {
-					return calledFunctionArgument[paramIndex].name;
-				}
-			}
-			return null;
-		}
-	}, {
-		key: 'generate',
-		value: function generate(options) {
-			throw new Error('generate not defined on BaseFunctionNode');
-		}
+  start >>>= 0
+  end >>>= 0
+  thisStart >>>= 0
+  thisEnd >>>= 0
 
-		/**
-   * @function
-   * @name astErrorOutput
-   * @ignore
-   * @desc To throw the AST error, with its location.
-   *
-   * @todo add location support fpr the AST error
-   *
-   * @param {Object} error - the error message output
-   * @param {Object} ast - the AST object where the error is
-   * @param {Object} funcParam - FunctionNode, that tracks compilation state
-   */
+  if (this === target) return 0
 
-	}, {
-		key: 'astErrorOutput',
-		value: function astErrorOutput(error, ast, funcParam) {
-			console.error(utils.getAstString(this.jsFunctionString, ast));
-			console.error(error, ast, funcParam);
-			return error;
-		}
-	}, {
-		key: 'astDebuggerStatement',
-		value: function astDebuggerStatement(arrNode, retArr, funcParam) {
-			return retArr;
-		}
-	}]);
+  var x = thisEnd - thisStart
+  var y = end - start
+  var len = Math.min(x, y)
 
-	return BaseFunctionNode;
-}();
-},{"../core/utils":74,"acorn":76}],57:[function(require,module,exports){
-'use strict';
+  var thisCopy = this.slice(thisStart, thisEnd)
+  var targetCopy = target.slice(start, end)
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i]
+      y = targetCopy[i]
+      break
+    }
+  }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
 
-var utils = require('../core/utils');
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1
 
-module.exports = function () {
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset
+    byteOffset = 0
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000
+  }
+  byteOffset = +byteOffset  // Coerce to Number.
+  if (isNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : (buffer.length - 1)
+  }
 
-	/**
-  * @constructor BaseKernel
-  * 
-  * @desc Implements the base class for Kernels, and is used as a 
-  * parent class for all Kernel implementations.
-  *
-  * This contains the basic methods needed by all Kernel implementations, 
-  * like setDimensions, addSubKernel, etc.
-  * 
-  * @prop {Array} paramNames - Name of the parameters of the kernel function
-  * @prop {String} fnString - Kernel function as a String
-  * @prop {Array} dimensions - Dimensions of the kernel function, this.thread.x, etc.
-  * @prop {Boolean} debug - Toggle debug mode
-  * @prop {String} graphical - Toggle graphical mode
-  * @prop {number} loopMaxIterations - Maximum number of loop iterations
-  * @prop {Object} constants - Global constants
-  * @prop {Array} subKernels - Sub kernels bound to this kernel instance
-  * @prop {Object} subKernelProperties - Sub kernels bound to this kernel instance as key/value pairs
-  * @prop {Array} subKernelOutputVariableNames - Names of the variables outputted by the subkerls
-  *
-  */
-	function BaseKernel(fnString, settings) {
-		_classCallCheck(this, BaseKernel);
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1
+    else byteOffset = buffer.length - 1
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0
+    else return -1
+  }
 
-		this.paramNames = utils.getParamNamesFromString(fnString);
-		this.fnString = fnString;
-		this.output = null;
-		this.debug = false;
-		this.graphical = false;
-		this.loopMaxIterations = 0;
-		this.constants = null;
-		this.wraparound = null;
-		this.hardcodeConstants = null;
-		this.outputToTexture = null;
-		this.texSize = null;
-		this._canvas = null;
-		this._webGl = null;
-		this.threadDim = null;
-		this.floatTextures = null;
-		this.floatOutput = null;
-		this.floatOutputForce = null;
-		this.addFunction = null;
-		this.functions = null;
-		this.nativeFunctions = null;
-		this.copyData = true;
-		this.subKernels = null;
-		this.subKernelProperties = null;
-		this.subKernelNames = null;
-		this.subKernelOutputVariableNames = null;
-		this.functionBuilder = null;
-		this.paramTypes = null;
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding)
+  }
 
-		for (var p in settings) {
-			if (!settings.hasOwnProperty(p) || !this.hasOwnProperty(p)) continue;
-			this[p] = settings[p];
-		}
-		if (settings.hasOwnProperty('canvas')) {
-			this._canvas = settings.canvas;
-		}
-		if (settings.hasOwnProperty('output')) {
-			this.setOutput(settings.output); // Flatten output object
-		}
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+  } else if (typeof val === 'number') {
+    val = val & 0xFF // Search for a byte value [0-255]
+    if (Buffer.TYPED_ARRAY_SUPPORT &&
+        typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+      }
+    }
+    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+  }
 
-		if (!this._canvas) this._canvas = utils.initCanvas();
-	}
+  throw new TypeError('val must be string, number or Buffer')
+}
 
-	_createClass(BaseKernel, [{
-		key: 'build',
-		value: function build() {
-			throw new Error('"build" not defined on Base');
-		}
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1
+  var arrLength = arr.length
+  var valLength = val.length
 
-		/**
-   * @memberOf KernelBase#
-   * @function
-   * @name setupParams
-   *
-   * @desc Setup the parameter types for the parameters
-   * supplied to the Kernel function
-   *
-   * @param {Array} args - The actual parameters sent to the Kernel
-   *
-   */
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase()
+    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+        encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1
+      }
+      indexSize = 2
+      arrLength /= 2
+      valLength /= 2
+      byteOffset /= 2
+    }
+  }
+
+  function read (buf, i) {
+    if (indexSize === 1) {
+      return buf[i]
+    } else {
+      return buf.readUInt16BE(i * indexSize)
+    }
+  }
+
+  var i
+  if (dir) {
+    var foundIndex = -1
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex
+        foundIndex = -1
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false
+          break
+        }
+      }
+      if (found) return i
+    }
+  }
 
-	}, {
-		key: 'setupParams',
-		value: function setupParams(args) {
-			var paramTypes = this.paramTypes = [];
-			for (var i = 0; i < args.length; i++) {
-				var param = args[i];
-				var paramType = utils.getArgumentType(param);
-				paramTypes.push(paramType);
-			}
-		}
-	}, {
-		key: 'setAddFunction',
-		value: function setAddFunction(cb) {
-			this.addFunction = cb;
-			return this;
-		}
-	}, {
-		key: 'setFunctions',
-		value: function setFunctions(functions) {
-			this.functions = functions;
-			return this;
-		}
+  return -1
+}
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setOutput
-   *
-   * @desc Set dimensions of the kernel function
-   *
-   * @param {Array|Object} output - The output array to set the kernel output size to
-   *
-   */
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1
+}
 
-	}, {
-		key: 'setOutput',
-		value: function setOutput(output) {
-			if (output.hasOwnProperty('x')) {
-				if (output.hasOwnProperty('y')) {
-					if (output.hasOwnProperty('z')) {
-						this.output = [output.x, output.y, output.z];
-					} else {
-						this.output = [output.x, output.y];
-					}
-				} else {
-					this.output = [output.x];
-				}
-			} else {
-				this.output = output;
-			}
-			return this;
-		}
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
 
-		/**
-   * @memberOf BaseKernel# 
-   * @function
-   * @name setDebug
-   *
-   * @desc Toggle debug mode
-   *
-   * @param {Boolean} flag - true to enable debug
-   *
-   */
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
 
-	}, {
-		key: 'setDebug',
-		value: function setDebug(flag) {
-			this.debug = flag;
-			return this;
-		}
+function hexWrite (buf, string, offset, length) {
+  offset = Number(offset) || 0
+  var remaining = buf.length - offset
+  if (!length) {
+    length = remaining
+  } else {
+    length = Number(length)
+    if (length > remaining) {
+      length = remaining
+    }
+  }
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setGraphical
-   *
-   * @desc Toggle graphical output mode
-   *
-   * @param {Boolean} flag - true to enable graphical output
-   *
-   */
+  // must be an even number of digits
+  var strLen = string.length
+  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
 
-	}, {
-		key: 'setGraphical',
-		value: function setGraphical(flag) {
-			this.graphical = flag;
-			return this;
-		}
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16)
+    if (isNaN(parsed)) return i
+    buf[offset + i] = parsed
+  }
+  return i
+}
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setLoopMaxIterations
-   *
-   * @desc Set the maximum number of loop iterations
-   *
-   * @param {number} max - iterations count
-   *
-   */
+function utf8Write (buf, string, offset, length) {
+  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
 
-	}, {
-		key: 'setLoopMaxIterations',
-		value: function setLoopMaxIterations(max) {
-			this.loopMaxIterations = max;
-			return this;
-		}
+function asciiWrite (buf, string, offset, length) {
+  return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setConstants
-   * @desc Set Constants
-   */
+function latin1Write (buf, string, offset, length) {
+  return asciiWrite(buf, string, offset, length)
+}
 
-	}, {
-		key: 'setConstants',
-		value: function setConstants(constants) {
-			this.constants = constants;
-			return this;
-		}
-	}, {
-		key: 'setWraparound',
-		value: function setWraparound(flag) {
-			console.warn('Wraparound mode is not supported and undocumented.');
-			this.wraparound = flag;
-			return this;
-		}
-	}, {
-		key: 'setHardcodeConstants',
-		value: function setHardcodeConstants(flag) {
-			this.hardcodeConstants = flag;
-			return this;
-		}
-	}, {
-		key: 'setOutputToTexture',
-		value: function setOutputToTexture(flag) {
-			this.outputToTexture = flag;
-			return this;
-		}
+function base64Write (buf, string, offset, length) {
+  return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setFloatTextures
-   *
-   * @desc Toggle texture output mode
-   *
-   * @param {Boolean} flag - true to enable floatTextures
-   *
-   */
+function ucs2Write (buf, string, offset, length) {
+  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
 
-	}, {
-		key: 'setFloatTextures',
-		value: function setFloatTextures(flag) {
-			this.floatTextures = flag;
-			return this;
-		}
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+  // Buffer#write(string)
+  if (offset === undefined) {
+    encoding = 'utf8'
+    length = this.length
+    offset = 0
+  // Buffer#write(string, encoding)
+  } else if (length === undefined && typeof offset === 'string') {
+    encoding = offset
+    length = this.length
+    offset = 0
+  // Buffer#write(string, offset[, length][, encoding])
+  } else if (isFinite(offset)) {
+    offset = offset | 0
+    if (isFinite(length)) {
+      length = length | 0
+      if (encoding === undefined) encoding = 'utf8'
+    } else {
+      encoding = length
+      length = undefined
+    }
+  // legacy write(string, encoding, offset, length) - remove in v0.13
+  } else {
+    throw new Error(
+      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+    )
+  }
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setFloatOutput
-   *
-   * @desc Toggle output mode
-   *
-   * @param {Boolean} flag - true to enable float
-   *
-   */
+  var remaining = this.length - offset
+  if (length === undefined || length > remaining) length = remaining
 
-	}, {
-		key: 'setFloatOutput',
-		value: function setFloatOutput(flag) {
-			this.floatOutput = flag;
-			return this;
-		}
-	}, {
-		key: 'setFloatOutputForce',
-		value: function setFloatOutputForce(flag) {
-			this.floatOutputForce = flag;
-			return this;
-		}
+  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+    throw new RangeError('Attempt to write outside buffer bounds')
+  }
+
+  if (!encoding) encoding = 'utf8'
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setCanvas
-   *
-   * @desc Bind the canvas to kernel
-   * 
-   * @param {Canvas} canvas - Canvas to bind
-   *
-   */
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'hex':
+        return hexWrite(this, string, offset, length)
 
-	}, {
-		key: 'setCanvas',
-		value: function setCanvas(canvas) {
-			this._canvas = canvas;
-			return this;
-		}
+      case 'utf8':
+      case 'utf-8':
+        return utf8Write(this, string, offset, length)
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name setCanvas
-   *
-   * @desc Bind the webGL instance to kernel
-   * 
-   * @param {Canvas} webGL - webGL instance to bind
-   *
-   */
+      case 'ascii':
+        return asciiWrite(this, string, offset, length)
 
-	}, {
-		key: 'setWebGl',
-		value: function setWebGl(webGl) {
-			this._webGl = webGl;
-			return this;
-		}
-	}, {
-		key: 'setCopyData',
-		value: function setCopyData(copyData) {
-			this.copyData = copyData;
-			return this;
-		}
+      case 'latin1':
+      case 'binary':
+        return latin1Write(this, string, offset, length)
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name getCanvas()
-   *
-   * @desc Returns the current canvas instance bound to the kernel
-   *
-   */
+      case 'base64':
+        // Warning: maxLength not taken into account in base64Write
+        return base64Write(this, string, offset, length)
 
-	}, {
-		key: 'getCanvas',
-		value: function getCanvas() {
-			return this._canvas;
-		}
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return ucs2Write(this, string, offset, length)
 
-		/**
-   * @memberOf BaseKernel#
-   * @function
-   * @name getWebGl()
-   *
-   * @desc Returns the current webGl instance bound to the kernel
-   *
-   */
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
 
-	}, {
-		key: 'getWebGl',
-		value: function getWebGl() {
-			return this._webGl;
-		}
-	}, {
-		key: 'validateOptions',
-		value: function validateOptions() {
-			throw new Error('validateOptions not defined');
-		}
-	}, {
-		key: 'exec',
-		value: function exec() {
-			return this.execute.apply(this, arguments);
-		}
-	}, {
-		key: 'execute',
-		value: function execute() {
-			var _this = this;
+Buffer.prototype.toJSON = function toJSON () {
+  return {
+    type: 'Buffer',
+    data: Array.prototype.slice.call(this._arr || this, 0)
+  }
+}
 
-			//
-			// Prepare the required objects
-			//
-			var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+function base64Slice (buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return base64.fromByteArray(buf)
+  } else {
+    return base64.fromByteArray(buf.slice(start, end))
+  }
+}
 
-			//
-			// Setup and return the promise, and execute the function, in synchronous mode
-			//
-			return utils.newPromise(function (accept, reject) {
-				try {
-					accept(_this.run.apply(_this, args));
-				} catch (e) {
-					//
-					// Error : throw rejection
-					//
-					reject(e);
-				}
-			});
-		}
+function utf8Slice (buf, start, end) {
+  end = Math.min(buf.length, end)
+  var res = []
 
-		/** 
-   * @memberOf BaseKernel#
-   * @function
-   * @name addSubKernel
-   *
-   * @desc Add a sub kernel to the root kernel instance.
-   * This is what `createKernelMap` uses.
-   *
-   * @param {String} fnString - function (as a String) of the subKernel to add
-   *
-   */
+  var i = start
+  while (i < end) {
+    var firstByte = buf[i]
+    var codePoint = null
+    var bytesPerSequence = (firstByte > 0xEF) ? 4
+      : (firstByte > 0xDF) ? 3
+      : (firstByte > 0xBF) ? 2
+      : 1
 
-	}, {
-		key: 'addSubKernel',
-		value: function addSubKernel(fnString) {
-			if (this.subKernels === null) {
-				this.subKernels = [];
-				this.subKernelNames = [];
-			}
-			this.subKernels.push(fnString);
-			this.subKernelNames.push(utils.getFunctionNameFromString(fnString));
-			return this;
-		}
+    if (i + bytesPerSequence <= end) {
+      var secondByte, thirdByte, fourthByte, tempCodePoint
 
-		/** 
-   * @memberOf BaseKernel#
-   * @function
-   * @name addSubKernelProperty
-   *
-   * @desc Add a sub kernel to the root kernel instance, indexed by a property name
-   * This is what `createKernelMap` uses.
-   *
-   * @param {String} property - property key for the subKernel
-   * @param {String} fnString - function (as a String) of the subKernel to add
-   *
-   */
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 0x80) {
+            codePoint = firstByte
+          }
+          break
+        case 2:
+          secondByte = buf[i + 1]
+          if ((secondByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+            if (tempCodePoint > 0x7F) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 3:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 4:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          fourthByte = buf[i + 3]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+              codePoint = tempCodePoint
+            }
+          }
+      }
+    }
 
-	}, {
-		key: 'addSubKernelProperty',
-		value: function addSubKernelProperty(property, fnString) {
-			if (this.subKernelProperties === null) {
-				this.subKernelProperties = {};
-				this.subKernelNames = [];
-			}
-			if (this.subKernelProperties.hasOwnProperty(property)) {
-				throw new Error('cannot add sub kernel ' + property + ', already defined');
-			}
-			this.subKernelProperties[property] = fnString;
-			this.subKernelNames.push(utils.getFunctionNameFromString(fnString));
-			return this;
-		}
-	}, {
-		key: 'addNativeFunction',
-		value: function addNativeFunction(name, source) {
-			this.functionBuilder.addNativeFunction(name, source);
-		}
-	}]);
+    if (codePoint === null) {
+      // we did not generate a valid codePoint so insert a
+      // replacement char (U+FFFD) and advance only 1 byte
+      codePoint = 0xFFFD
+      bytesPerSequence = 1
+    } else if (codePoint > 0xFFFF) {
+      // encode to utf16 (surrogate pair dance)
+      codePoint -= 0x10000
+      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+      codePoint = 0xDC00 | codePoint & 0x3FF
+    }
 
-	return BaseKernel;
-}();
-},{"../core/utils":74}],58:[function(require,module,exports){
-'use strict';
+    res.push(codePoint)
+    i += bytesPerSequence
+  }
 
-var utils = require('../core/utils');
+  return decodeCodePointsArray(res)
+}
 
-module.exports = function kernelRunShortcut(kernel) {
-	var shortcut = function shortcut() {
-		return kernel.run.apply(kernel, arguments);
-	};
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
 
-	utils.allPropertiesOf(kernel).forEach(function (key) {
-		if (key[0] === '_' && key[1] === '_') return;
-		if (typeof kernel[key] === 'function') {
-			if (key.substring(0, 3) === 'add' || key.substring(0, 3) === 'set') {
-				shortcut[key] = function () {
-					kernel[key].apply(kernel, arguments);
-					return shortcut;
-				};
-			} else {
-				shortcut[key] = kernel[key].bind(kernel);
-			}
-		} else {
-			shortcut.__defineGetter__(key, function () {
-				return kernel[key];
-			});
-			shortcut.__defineSetter__(key, function (value) {
-				kernel[key] = value;
-			});
-		}
-	});
+function decodeCodePointsArray (codePoints) {
+  var len = codePoints.length
+  if (len <= MAX_ARGUMENTS_LENGTH) {
+    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+  }
 
-	shortcut.kernel = kernel;
+  // Decode in chunks to avoid "call stack size exceeded".
+  var res = ''
+  var i = 0
+  while (i < len) {
+    res += String.fromCharCode.apply(
+      String,
+      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+    )
+  }
+  return res
+}
 
-	return shortcut;
-};
-},{"../core/utils":74}],59:[function(require,module,exports){
-'use strict';
+function asciiSlice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i] & 0x7F)
+  }
+  return ret
+}
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function latin1Slice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
 
-var utils = require('../core/utils');
-var kernelRunShortcut = require('./kernel-run-shortcut');
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i])
+  }
+  return ret
+}
 
-module.exports = function () {
+function hexSlice (buf, start, end) {
+  var len = buf.length
 
-	/**
-  * @constructor BaseRunner
-  *
-  * @desc Represents the 'private/protected' namespace of the GPU class
-  *
-  * <p>I know @private makes more sense, but since the documentation engine state is undetirmined.
-  * (See https://github.com/gpujs/gpu.js/issues/19 regarding documentation engine issue)
-  * File isolation is currently the best way to go. </p>
-  *
-  * *base.js* internal functions namespace <br>
-  * *gpu.js* PUBLIC function namespace <br>
-  *
-  * @prop {Object} settings - Settings object used to set Dimensions, etc.
-  * @prop {String} kernel - Current kernel instance
-  * @prop {Object} canvas - Canvas instance attached to the kernel
-  * @prop {Object} webGl - WebGl instance attached to the kernel
-  * @prop {Function} fn - Kernel function to run
-  * @prop {Object} functionBuilder - FunctionBuilder instance
-  * @prop {String} fnString - Kernel function (as a String)
-  * @prop {String} endianness - endian information like Little-endian, Big-endian.
-  *
-  */
+  if (!start || start < 0) start = 0
+  if (!end || end < 0 || end > len) end = len
 
-	function BaseRunner(functionBuilder, settings) {
-		_classCallCheck(this, BaseRunner);
+  var out = ''
+  for (var i = start; i < end; ++i) {
+    out += toHex(buf[i])
+  }
+  return out
+}
 
-		settings = settings || {};
-		this.kernel = settings.kernel;
-		this.canvas = settings.canvas;
-		this.webGl = settings.webGl;
-		this.fn = null;
-		this.functionBuilder = functionBuilder;
-		this.fnString = null;
-		this.endianness = utils.systemEndianness();
-		this.functionBuilder.polyfillStandardFunctions();
-	}
+function utf16leSlice (buf, start, end) {
+  var bytes = buf.slice(start, end)
+  var res = ''
+  for (var i = 0; i < bytes.length; i += 2) {
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+  }
+  return res
+}
 
-	/**
-  * @memberOf BaseRunner#
-  * @function
-  * @name textureToArray
-  *
-  * @desc Converts the provided Texture instance to a JavaScript Array
-  *
-  * @param {Object} texture - Texture Object
-  *
-  */
+Buffer.prototype.slice = function slice (start, end) {
+  var len = this.length
+  start = ~~start
+  end = end === undefined ? len : ~~end
 
+  if (start < 0) {
+    start += len
+    if (start < 0) start = 0
+  } else if (start > len) {
+    start = len
+  }
 
-	_createClass(BaseRunner, [{
-		key: 'textureToArray',
-		value: function textureToArray(texture) {
-			var copy = this.createKernel(function (x) {
-				return x[this.thread.z][this.thread.y][this.thread.x];
-			});
+  if (end < 0) {
+    end += len
+    if (end < 0) end = 0
+  } else if (end > len) {
+    end = len
+  }
 
-			return copy(texture);
-		}
+  if (end < start) end = start
 
-		/**
-   * @memberOf BaseRunner#
-   * @function
-   *
-   * @name deleteTexture
-   *
-   * @desc Deletes the provided Texture instance
-   *
-   * @param {Object} texture - Texture Object
-   */
+  var newBuf
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    newBuf = this.subarray(start, end)
+    newBuf.__proto__ = Buffer.prototype
+  } else {
+    var sliceLen = end - start
+    newBuf = new Buffer(sliceLen, undefined)
+    for (var i = 0; i < sliceLen; ++i) {
+      newBuf[i] = this[i + start]
+    }
+  }
 
-	}, {
-		key: 'deleteTexture',
-		value: function deleteTexture(texture) {
-			this.webGl.deleteTexture(texture.texture);
-		}
+  return newBuf
+}
 
-		/**
-   * @memberOf BaseRunner#
-   * @function
-   * @name buildPromiseKernel
-   *
-   * @desc Get and returns the ASYNCHRONOUS executor, of a class and kernel
-   * This returns a Promise object from an argument set.
-   *
-   * Note that there is no current implementation.
-   *
-   */
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
 
-	}, {
-		key: 'buildPromiseKernel',
-		value: function buildPromiseKernel() {
-			throw new Error('not yet implemented');
-		}
-	}, {
-		key: 'getMode',
-		value: function getMode() {
-			throw new Error('"mode" not implemented on BaseRunner');
-		}
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
 
-		/**
-   * @memberOf BaseRunner#
-   * @function
-   *
-   * @name buildKernel
-   *
-   * @desc Get and returns the Synchronous executor, of a class and kernel
-   * Which returns the result directly after passing the arguments.
-   *
-   */
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
 
-	}, {
-		key: 'buildKernel',
-		value: function buildKernel(fn, settings) {
-			settings = Object.assign({}, settings || {});
-			var fnString = fn.toString();
-			if (!settings.functionBuilder) {
-				settings.functionBuilder = this.functionBuilder;
-			}
+  return val
+}
 
-			if (!settings.canvas) {
-				settings.canvas = this.canvas;
-			}
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    checkOffset(offset, byteLength, this.length)
+  }
 
-			if (!settings.webGl) {
-				settings.webGl = this.webgl;
-			}
+  var val = this[offset + --byteLength]
+  var mul = 1
+  while (byteLength > 0 && (mul *= 0x100)) {
+    val += this[offset + --byteLength] * mul
+  }
 
-			return kernelRunShortcut(new this.Kernel(fnString, settings));
-		}
-	}]);
+  return val
+}
 
-	return BaseRunner;
-}();
-},{"../core/utils":74,"./kernel-run-shortcut":58}],60:[function(require,module,exports){
-'use strict';
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  return this[offset]
+}
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  return ((this[offset]) |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16)) +
+      (this[offset + 3] * 0x1000000)
+}
 
-var FunctionBuilderBase = require('../function-builder-base');
-var WebGLFunctionNode = require('./function-node');
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
 
-/**
- * @class WebGLFunctionBuilder
- *
- * @extends FunctionBuilderBase
- *
- * @desc Builds webGl functions (shaders) from JavaScript function Strings
- *
- */
-module.exports = function (_FunctionBuilderBase) {
-	_inherits(WebGLFunctionBuilder, _FunctionBuilderBase);
+  return (this[offset] * 0x1000000) +
+    ((this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    this[offset + 3])
+}
 
-	function WebGLFunctionBuilder() {
-		_classCallCheck(this, WebGLFunctionBuilder);
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
 
-		var _this = _possibleConstructorReturn(this, (WebGLFunctionBuilder.__proto__ || Object.getPrototypeOf(WebGLFunctionBuilder)).call(this));
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
+  mul *= 0x80
 
-		_this.Node = WebGLFunctionNode;
-		return _this;
-	}
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
 
-	//---------------------------------------------------------
-	//
-	//  Polyfill stuff
-	//
-	//---------------------------------------------------------
+  return val
+}
 
-	// Round function used in polyfill
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
 
+  var i = byteLength
+  var mul = 1
+  var val = this[offset + --i]
+  while (i > 0 && (mul *= 0x100)) {
+    val += this[offset + --i] * mul
+  }
+  mul *= 0x80
 
-	_createClass(WebGLFunctionBuilder, [{
-		key: 'polyfillStandardFunctions',
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
 
+  return val
+}
 
-		/**
-   * @memberOf FunctionBuilderBase#
-   * @function
-   * @name polyfillStandardFunctions
-   *
-   * @desc Polyfill in the missing Math functions (round)
-   *
-   */
-		value: function polyfillStandardFunctions() {
-			this.addFunction('round', _round);
-		}
-	}], [{
-		key: 'round',
-		value: function round(a) {
-			return _round(a);
-		}
-	}]);
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  if (!(this[offset] & 0x80)) return (this[offset])
+  return ((0xff - this[offset] + 1) * -1)
+}
 
-	return WebGLFunctionBuilder;
-}(FunctionBuilderBase);
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset] | (this[offset + 1] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
 
-function _round(a) {
-	return Math.floor(a + 0.5);
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset + 1] | (this[offset] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
 }
-},{"../function-builder-base":55,"./function-node":61}],61:[function(require,module,exports){
-'use strict';
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  return (this[offset]) |
+    (this[offset + 1] << 8) |
+    (this[offset + 2] << 16) |
+    (this[offset + 3] << 24)
+}
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  return (this[offset] << 24) |
+    (this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    (this[offset + 3])
+}
 
-var FunctionNodeBase = require('../function-node-base');
-var utils = require('../../core/utils');
-// Closure capture for the ast function, prevent collision with existing AST functions
-// The prefixes to use
-var jsMathPrefix = 'Math.';
-var localPrefix = 'this.';
-var constantsPrefix = 'this.constants.';
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
 
-var DECODE32_ENCODE32 = /decode32\(\s+encode32\(/g;
-var ENCODE32_DECODE32 = /encode32\(\s+decode32\(/g;
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
 
-/** 
- * @class WebGLFunctionNode
- *
- * @desc [INTERNAL] Takes in a function node, and does all the AST voodoo required to generate its respective webGL code.
- *
- * @extends FunctionNodeBase
- *
- * @param {functionNode} inNode - The function node object
- *
- * @returns the converted webGL function string
- *
- */
-module.exports = function (_FunctionNodeBase) {
-	_inherits(WebGLFunctionNode, _FunctionNodeBase);
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
 
-	function WebGLFunctionNode() {
-		_classCallCheck(this, WebGLFunctionNode);
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, false, 52, 8)
+}
 
-		return _possibleConstructorReturn(this, (WebGLFunctionNode.__proto__ || Object.getPrototypeOf(WebGLFunctionNode)).apply(this, arguments));
-	}
+function checkInt (buf, value, offset, ext, max, min) {
+  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
 
-	_createClass(WebGLFunctionNode, [{
-		key: 'generate',
-		value: function generate() {
-			if (this.debug) {
-				console.log(this);
-			}
-			if (this.prototypeOnly) {
-				return WebGLFunctionNode.astFunctionPrototype(this.getJsAST(), [], this).join('').trim();
-			} else {
-				this.functionStringArray = this.astGeneric(this.getJsAST(), [], this);
-			}
-			this.functionString = webGlRegexOptimize(this.functionStringArray.join('').trim());
-			return this.functionString;
-		}
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astGeneric
-   *
-   * @desc Parses the abstract syntax tree for generically to its respective function
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed webgl string array
-   */
+  var mul = 1
+  var i = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
 
-	}, {
-		key: 'astGeneric',
-		value: function astGeneric(ast, retArr, funcParam) {
-			if (ast === null) {
-				throw this.astErrorOutput('NULL ast', ast, funcParam);
-			} else {
-				if (Array.isArray(ast)) {
-					for (var i = 0; i < ast.length; i++) {
-						this.astGeneric(ast[i], retArr, funcParam);
-					}
-					return retArr;
-				}
+  return offset + byteLength
+}
 
-				switch (ast.type) {
-					case 'FunctionDeclaration':
-						return this.astFunctionDeclaration(ast, retArr, funcParam);
-					case 'FunctionExpression':
-						return this.astFunctionExpression(ast, retArr, funcParam);
-					case 'ReturnStatement':
-						return this.astReturnStatement(ast, retArr, funcParam);
-					case 'Literal':
-						return this.astLiteral(ast, retArr, funcParam);
-					case 'BinaryExpression':
-						return this.astBinaryExpression(ast, retArr, funcParam);
-					case 'Identifier':
-						return this.astIdentifierExpression(ast, retArr, funcParam);
-					case 'AssignmentExpression':
-						return this.astAssignmentExpression(ast, retArr, funcParam);
-					case 'ExpressionStatement':
-						return this.astExpressionStatement(ast, retArr, funcParam);
-					case 'EmptyStatement':
-						return this.astEmptyStatement(ast, retArr, funcParam);
-					case 'BlockStatement':
-						return this.astBlockStatement(ast, retArr, funcParam);
-					case 'IfStatement':
-						return this.astIfStatement(ast, retArr, funcParam);
-					case 'BreakStatement':
-						return this.astBreakStatement(ast, retArr, funcParam);
-					case 'ContinueStatement':
-						return this.astContinueStatement(ast, retArr, funcParam);
-					case 'ForStatement':
-						return this.astForStatement(ast, retArr, funcParam);
-					case 'WhileStatement':
-						return this.astWhileStatement(ast, retArr, funcParam);
-					case 'VariableDeclaration':
-						return this.astVariableDeclaration(ast, retArr, funcParam);
-					case 'VariableDeclarator':
-						return this.astVariableDeclarator(ast, retArr, funcParam);
-					case 'ThisExpression':
-						return this.astThisExpression(ast, retArr, funcParam);
-					case 'SequenceExpression':
-						return this.astSequenceExpression(ast, retArr, funcParam);
-					case 'UnaryExpression':
-						return this.astUnaryExpression(ast, retArr, funcParam);
-					case 'UpdateExpression':
-						return this.astUpdateExpression(ast, retArr, funcParam);
-					case 'LogicalExpression':
-						return this.astLogicalExpression(ast, retArr, funcParam);
-					case 'MemberExpression':
-						return this.astMemberExpression(ast, retArr, funcParam);
-					case 'CallExpression':
-						return this.astCallExpression(ast, retArr, funcParam);
-					case 'ArrayExpression':
-						return this.astArrayExpression(ast, retArr, funcParam);
-					case 'DebuggerStatement':
-						return this.astDebuggerStatement(ast, retArr, funcParam);
-				}
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
 
-				throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast, funcParam);
-			}
-		}
+  var i = byteLength - 1
+  var mul = 1
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionDeclaration
-   *
-   * @desc Parses the abstract syntax tree for to its *named function declaration*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+  return offset + byteLength
+}
 
-	}, {
-		key: 'astFunctionDeclaration',
-		value: function astFunctionDeclaration(ast, retArr, funcParam) {
-			if (this.addFunction) {
-				this.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
-			}
-			return retArr;
-		}
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionPrototype
-   * @static
-   *
-   * @desc Parses the abstract syntax tree for to its *named function prototype*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+      (littleEndian ? i : 1 - i) * 8
+  }
+}
 
-	}, {
-		key: 'astFunctionExpression',
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+  } else {
+    objectWriteUInt16(this, value, offset, true)
+  }
+  return offset + 2
+}
 
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = (value & 0xff)
+  } else {
+    objectWriteUInt16(this, value, offset, false)
+  }
+  return offset + 2
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astFunctionExpression
-   *
-   * @desc Parses the abstract syntax tree for to its *named function*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
-		value: function astFunctionExpression(ast, retArr, funcParam) {
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffffffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+  }
+}
 
-			// Setup function return type and name
-			if (funcParam.isRootKernel) {
-				retArr.push('void');
-				funcParam.kernalAst = ast;
-			} else {
-				retArr.push(funcParam.returnType);
-			}
-			retArr.push(' ');
-			retArr.push(funcParam.functionName);
-			retArr.push('(');
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset + 3] = (value >>> 24)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 1] = (value >>> 8)
+    this[offset] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, true)
+  }
+  return offset + 4
+}
 
-			if (!funcParam.isRootKernel) {
-				// Arguments handling
-				for (var i = 0; i < funcParam.paramNames.length; ++i) {
-					var paramName = funcParam.paramNames[i];
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, false)
+  }
+  return offset + 4
+}
 
-					if (i > 0) {
-						retArr.push(', ');
-					}
-					var type = funcParam.getParamType(paramName);
-					switch (type) {
-						case 'Texture':
-						case 'Input':
-						case 'Array':
-							retArr.push('sampler2D');
-							break;
-						default:
-							retArr.push('float');
-					}
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1)
 
-					retArr.push(' ');
-					retArr.push('user_');
-					retArr.push(paramName);
-				}
-			}
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
 
-			// Function opening
-			retArr.push(') {\n');
+  var i = 0
+  var mul = 1
+  var sub = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
 
-			// Body statement iteration
-			for (var _i = 0; _i < ast.body.body.length; ++_i) {
-				this.astGeneric(ast.body.body[_i], retArr, funcParam);
-				retArr.push('\n');
-			}
+  return offset + byteLength
+}
 
-			// Function closing
-			retArr.push('}\n');
-			return retArr;
-		}
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1)
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astReturnStatement
-   *
-   * @desc Parses the abstract syntax tree for to *return* statement
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Object} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
 
-	}, {
-		key: 'astReturnStatement',
-		value: function astReturnStatement(ast, retArr, funcParam) {
-			if (funcParam.isRootKernel) {
-				retArr.push('kernelResult = ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-				retArr.push('return;');
-			} else if (funcParam.isSubKernel) {
-				retArr.push(funcParam.functionName + 'Result = ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-				retArr.push('return ' + funcParam.functionName + 'Result;');
-			} else {
-				retArr.push('return ');
-				this.astGeneric(ast.argument, retArr, funcParam);
-				retArr.push(';');
-			}
+  var i = byteLength - 1
+  var mul = 1
+  var sub = 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
 
-			//throw this.astErrorOutput(
-			//	'Non main function return, is not supported : '+funcParam.currentFunctionNamespace,
-			//	ast, funcParam
-			//);
+  return offset + byteLength
+}
 
-			return retArr;
-		}
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  if (value < 0) value = 0xff + value + 1
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astLiteral
-   *
-   * @desc Parses the abstract syntax tree for *literal value*
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+  } else {
+    objectWriteUInt16(this, value, offset, true)
+  }
+  return offset + 2
+}
 
-	}, {
-		key: 'astLiteral',
-		value: function astLiteral(ast, retArr, funcParam) {
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = (value & 0xff)
+  } else {
+    objectWriteUInt16(this, value, offset, false)
+  }
+  return offset + 2
+}
 
-			// Reject non numeric literals
-			if (isNaN(ast.value)) {
-				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast, funcParam);
-			}
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 3] = (value >>> 24)
+  } else {
+    objectWriteUInt32(this, value, offset, true)
+  }
+  return offset + 4
+}
 
-			// Push the literal value as a float/int
-			retArr.push(ast.value);
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (value < 0) value = 0xffffffff + value + 1
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, false)
+  }
+  return offset + 4
+}
 
-			// If it was an int, node made a float
-			if (Number.isInteger(ast.value)) {
-				retArr.push('.0');
-			}
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+  if (offset < 0) throw new RangeError('Index out of range')
+}
 
-			return retArr;
-		}
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 23, 4)
+  return offset + 4
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBinaryExpression
-   *
-   * @desc Parses the abstract syntax tree for *binary* expression
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, true, noAssert)
+}
 
-	}, {
-		key: 'astBinaryExpression',
-		value: function astBinaryExpression(ast, retArr, funcParam) {
-			retArr.push('(');
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, false, noAssert)
+}
 
-			if (ast.operator === '%') {
-				retArr.push('mod(');
-				this.astGeneric(ast.left, retArr, funcParam);
-				retArr.push(',');
-				this.astGeneric(ast.right, retArr, funcParam);
-				retArr.push(')');
-			} else if (ast.operator === '===') {
-				this.astGeneric(ast.left, retArr, funcParam);
-				retArr.push('==');
-				this.astGeneric(ast.right, retArr, funcParam);
-			} else if (ast.operator === '!==') {
-				this.astGeneric(ast.left, retArr, funcParam);
-				retArr.push('!=');
-				this.astGeneric(ast.right, retArr, funcParam);
-			} else {
-				this.astGeneric(ast.left, retArr, funcParam);
-				retArr.push(ast.operator);
-				this.astGeneric(ast.right, retArr, funcParam);
-			}
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 52, 8)
+  return offset + 8
+}
 
-			retArr.push(')');
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, true, noAssert)
+}
 
-			return retArr;
-		}
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, false, noAssert)
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astIdentifierExpression
-   *
-   * @desc Parses the abstract syntax tree for *identifier* expression
-   *
-   * @param {Object} idtNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+  if (!start) start = 0
+  if (!end && end !== 0) end = this.length
+  if (targetStart >= target.length) targetStart = target.length
+  if (!targetStart) targetStart = 0
+  if (end > 0 && end < start) end = start
 
-	}, {
-		key: 'astIdentifierExpression',
-		value: function astIdentifierExpression(idtNode, retArr, funcParam) {
-			if (idtNode.type !== 'Identifier') {
-				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode, funcParam);
-			}
+  // Copy 0 bytes; we're done
+  if (end === start) return 0
+  if (target.length === 0 || this.length === 0) return 0
+
+  // Fatal error conditions
+  if (targetStart < 0) {
+    throw new RangeError('targetStart out of bounds')
+  }
+  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+  if (end < 0) throw new RangeError('sourceEnd out of bounds')
 
-			switch (idtNode.name) {
-				case 'gpu_threadX':
-					retArr.push('threadId.x');
-					break;
-				case 'gpu_threadY':
-					retArr.push('threadId.y');
-					break;
-				case 'gpu_threadZ':
-					retArr.push('threadId.z');
-					break;
-				case 'gpu_outputX':
-					retArr.push('uOutputDim.x');
-					break;
-				case 'gpu_outputY':
-					retArr.push('uOutputDim.y');
-					break;
-				case 'gpu_outputZ':
-					retArr.push('uOutputDim.z');
-					break;
-				default:
-					if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
-						retArr.push('constants_' + idtNode.name);
-					} else {
-						var userParamName = funcParam.getUserParamName(idtNode.name);
-						if (userParamName !== null) {
-							retArr.push('user_' + userParamName);
-						} else {
-							retArr.push('user_' + idtNode.name);
-						}
-					}
-			}
+  // Are we oob?
+  if (end > this.length) end = this.length
+  if (target.length - targetStart < end - start) {
+    end = target.length - targetStart + start
+  }
 
-			return retArr;
-		}
+  var len = end - start
+  var i
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astForStatement
-   *
-   * @desc Parses the abstract syntax tree forfor *for-loop* expression
-   *
-   * @param {Object} forNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed webgl string
-   */
+  if (this === target && start < targetStart && targetStart < end) {
+    // descending copy from end
+    for (i = len - 1; i >= 0; --i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+    // ascending copy from start
+    for (i = 0; i < len; ++i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, start + len),
+      targetStart
+    )
+  }
 
-	}, {
-		key: 'astForStatement',
-		value: function astForStatement(forNode, retArr, funcParam) {
-			if (forNode.type !== 'ForStatement') {
-				throw this.astErrorOutput('Invalid for statment', forNode, funcParam);
-			}
+  return len
+}
 
-			if (forNode.test && forNode.test.type === 'BinaryExpression') {
-				if (forNode.test.right.type === 'Identifier' && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start
+      start = 0
+      end = this.length
+    } else if (typeof end === 'string') {
+      encoding = end
+      end = this.length
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if (code < 256) {
+        val = code
+      }
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string')
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding)
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  }
 
-					if (!this.loopMaxIterations) {
-						console.warn('Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior.');
-						console.warn('Set loopMaxIterations or use a for loop of fixed length to silence this message.');
-					}
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index')
+  }
 
-					retArr.push('for (');
-					this.astGeneric(forNode.init, retArr, funcParam);
-					this.astGeneric(forNode.test.left, retArr, funcParam);
-					retArr.push(forNode.test.operator);
-					retArr.push('LOOP_MAX');
-					retArr.push(';');
-					this.astGeneric(forNode.update, retArr, funcParam);
-					retArr.push(')');
+  if (end <= start) {
+    return this
+  }
 
-					retArr.push('{\n');
-					retArr.push('if (');
-					this.astGeneric(forNode.test.left, retArr, funcParam);
-					retArr.push(forNode.test.operator);
-					this.astGeneric(forNode.test.right, retArr, funcParam);
-					retArr.push(') {\n');
-					if (forNode.body.type === 'BlockStatement') {
-						for (var i = 0; i < forNode.body.body.length; i++) {
-							this.astGeneric(forNode.body.body[i], retArr, funcParam);
-						}
-					} else {
-						this.astGeneric(forNode.body, retArr, funcParam);
-					}
-					retArr.push('} else {\n');
-					retArr.push('break;\n');
-					retArr.push('}\n');
-					retArr.push('}\n');
+  start = start >>> 0
+  end = end === undefined ? this.length : end >>> 0
 
-					return retArr;
-				} else {
-					var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));
-					var updateArgument = forNode.update.argument;
-					if (!Array.isArray(declarations) || declarations.length < 1) {
-						console.log(this.jsFunctionString);
-						throw new Error('Error: Incompatible for loop declaration');
-					}
+  if (!val) val = 0
 
-					if (declarations.length > 1) {
-						var initArgument = null;
-						for (var _i2 = 0; _i2 < declarations.length; _i2++) {
-							var declaration = declarations[_i2];
-							if (declaration.id.name === updateArgument.name) {
-								initArgument = declaration;
-								declarations.splice(_i2, 1);
-							} else {
-								retArr.push('float ');
-								this.astGeneric(declaration, retArr, funcParam);
-								retArr.push(';');
-							}
-						}
+  var i
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val)
+      ? val
+      : utf8ToBytes(new Buffer(val, encoding).toString())
+    var len = bytes.length
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len]
+    }
+  }
 
-						retArr.push('for (float ');
-						this.astGeneric(initArgument, retArr, funcParam);
-						retArr.push(';');
-					} else {
-						retArr.push('for (');
-						this.astGeneric(forNode.init, retArr, funcParam);
-					}
+  return this
+}
 
-					this.astGeneric(forNode.test, retArr, funcParam);
-					retArr.push(';');
-					this.astGeneric(forNode.update, retArr, funcParam);
-					retArr.push(')');
-					this.astGeneric(forNode.body, retArr, funcParam);
-					return retArr;
-				}
-			}
+// HELPER FUNCTIONS
+// ================
 
-			throw this.astErrorOutput('Invalid for statement', forNode, funcParam);
-		}
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astWhileStatement
-   *
-   * @desc Parses the abstract syntax tree for *while* loop
-   *
-   *
-   * @param {Object} whileNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the parsed webgl string
-   */
+function base64clean (str) {
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return ''
+  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+  while (str.length % 4 !== 0) {
+    str = str + '='
+  }
+  return str
+}
 
-	}, {
-		key: 'astWhileStatement',
-		value: function astWhileStatement(whileNode, retArr, funcParam) {
-			if (whileNode.type !== 'WhileStatement') {
-				throw this.astErrorOutput('Invalid while statment', whileNode, funcParam);
-			}
+function stringtrim (str) {
+  if (str.trim) return str.trim()
+  return str.replace(/^\s+|\s+$/g, '')
+}
 
-			retArr.push('for (float i = 0.0; i < LOOP_MAX; i++) {');
-			retArr.push('if (');
-			this.astGeneric(whileNode.test, retArr, funcParam);
-			retArr.push(') {\n');
-			this.astGeneric(whileNode.body, retArr, funcParam);
-			retArr.push('} else {\n');
-			retArr.push('break;\n');
-			retArr.push('}\n');
-			retArr.push('}\n');
+function toHex (n) {
+  if (n < 16) return '0' + n.toString(16)
+  return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+  units = units || Infinity
+  var codePoint
+  var length = string.length
+  var leadSurrogate = null
+  var bytes = []
 
-			return retArr;
-		}
+  for (var i = 0; i < length; ++i) {
+    codePoint = string.charCodeAt(i)
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astAssignmentExpression
-   *
-   * @desc Parses the abstract syntax tree for *Assignment* Expression
-   *
-   * @param {Object} assNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+    // is surrogate component
+    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+      // last char was a lead
+      if (!leadSurrogate) {
+        // no lead yet
+        if (codePoint > 0xDBFF) {
+          // unexpected trail
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        } else if (i + 1 === length) {
+          // unpaired lead
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        }
 
-	}, {
-		key: 'astAssignmentExpression',
-		value: function astAssignmentExpression(assNode, retArr, funcParam) {
-			if (assNode.operator === '%=') {
-				this.astGeneric(assNode.left, retArr, funcParam);
-				retArr.push('=');
-				retArr.push('mod(');
-				this.astGeneric(assNode.left, retArr, funcParam);
-				retArr.push(',');
-				this.astGeneric(assNode.right, retArr, funcParam);
-				retArr.push(')');
-			} else {
-				this.astGeneric(assNode.left, retArr, funcParam);
-				retArr.push(assNode.operator);
-				this.astGeneric(assNode.right, retArr, funcParam);
-				return retArr;
-			}
-		}
+        // valid lead
+        leadSurrogate = codePoint
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astEmptyStatement
-   *
-   * @desc Parses the abstract syntax tree for an *Empty* Statement
-   *
-   * @param {Object} eNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+        continue
+      }
 
-	}, {
-		key: 'astEmptyStatement',
-		value: function astEmptyStatement(eNode, retArr, funcParam) {
-			//retArr.push(';\n');
-			return retArr;
-		}
+      // 2 leads in a row
+      if (codePoint < 0xDC00) {
+        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+        leadSurrogate = codePoint
+        continue
+      }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBlockStatement
-   *
-   * @desc Parses the abstract syntax tree for *Block* statement
-   *
-   * @param {Object} bnode - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+      // valid surrogate pair
+      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+    } else if (leadSurrogate) {
+      // valid bmp char, but last char was a lead
+      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+    }
 
-	}, {
-		key: 'astBlockStatement',
-		value: function astBlockStatement(bNode, retArr, funcParam) {
-			retArr.push('{\n');
-			for (var i = 0; i < bNode.body.length; i++) {
-				this.astGeneric(bNode.body[i], retArr, funcParam);
-			}
-			retArr.push('}\n');
-			return retArr;
-		}
+    leadSurrogate = null
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astExpressionStatement
-   *
-   * @desc Parses the abstract syntax tree for *generic expression* statement
-   *
-   * @param {Object} esNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+    // encode utf8
+    if (codePoint < 0x80) {
+      if ((units -= 1) < 0) break
+      bytes.push(codePoint)
+    } else if (codePoint < 0x800) {
+      if ((units -= 2) < 0) break
+      bytes.push(
+        codePoint >> 0x6 | 0xC0,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x10000) {
+      if ((units -= 3) < 0) break
+      bytes.push(
+        codePoint >> 0xC | 0xE0,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x110000) {
+      if ((units -= 4) < 0) break
+      bytes.push(
+        codePoint >> 0x12 | 0xF0,
+        codePoint >> 0xC & 0x3F | 0x80,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else {
+      throw new Error('Invalid code point')
+    }
+  }
 
-	}, {
-		key: 'astExpressionStatement',
-		value: function astExpressionStatement(esNode, retArr, funcParam) {
-			this.astGeneric(esNode.expression, retArr, funcParam);
-			retArr.push(';\n');
-			return retArr;
-		}
+  return bytes
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astVariableDeclaration
-   *
-   * @desc Parses the abstract syntax tree for *Variable Declaration*
-   *
-   * @param {Object} vardecNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function asciiToBytes (str) {
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    // Node's code seems to be doing this and not & 0x7F..
+    byteArray.push(str.charCodeAt(i) & 0xFF)
+  }
+  return byteArray
+}
 
-	}, {
-		key: 'astVariableDeclaration',
-		value: function astVariableDeclaration(vardecNode, retArr, funcParam) {
-			retArr.push('float ');
-			for (var i = 0; i < vardecNode.declarations.length; i++) {
-				if (i > 0) {
-					retArr.push(',');
-				}
-				this.astGeneric(vardecNode.declarations[i], retArr, funcParam);
-			}
-			retArr.push(';');
-			return retArr;
-		}
+function utf16leToBytes (str, units) {
+  var c, hi, lo
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    if ((units -= 2) < 0) break
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astVariableDeclarator
-   *
-   * @desc Parses the abstract syntax tree for *Variable Declarator*
-   *
-   * @param {Object} ivardecNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+    c = str.charCodeAt(i)
+    hi = c >> 8
+    lo = c % 256
+    byteArray.push(lo)
+    byteArray.push(hi)
+  }
 
-	}, {
-		key: 'astVariableDeclarator',
-		value: function astVariableDeclarator(ivardecNode, retArr, funcParam) {
-			this.astGeneric(ivardecNode.id, retArr, funcParam);
-			if (ivardecNode.init !== null) {
-				retArr.push('=');
-				this.astGeneric(ivardecNode.init, retArr, funcParam);
-			}
-			return retArr;
-		}
+  return byteArray
+}
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astIfStatement
-   *
-   * @desc Parses the abstract syntax tree for *If* Statement
-   *
-   * @param {Object} ifNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function base64ToBytes (str) {
+  return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+  for (var i = 0; i < length; ++i) {
+    if ((i + offset >= dst.length) || (i >= src.length)) break
+    dst[i + offset] = src[i]
+  }
+  return i
+}
 
-	}, {
-		key: 'astIfStatement',
-		value: function astIfStatement(ifNode, retArr, funcParam) {
-			retArr.push('if (');
-			this.astGeneric(ifNode.test, retArr, funcParam);
-			retArr.push(')');
-			if (ifNode.consequent.type === 'BlockStatement') {
-				this.astGeneric(ifNode.consequent, retArr, funcParam);
-			} else {
-				retArr.push(' {\n');
-				this.astGeneric(ifNode.consequent, retArr, funcParam);
-				retArr.push('\n}\n');
-			}
+function isnan (val) {
+  return val !== val // eslint-disable-line no-self-compare
+}
 
-			if (ifNode.alternate) {
-				retArr.push('else ');
-				if (ifNode.alternate.type === 'BlockStatement') {
-					this.astGeneric(ifNode.alternate, retArr, funcParam);
-				} else {
-					retArr.push(' {\n');
-					this.astGeneric(ifNode.alternate, retArr, funcParam);
-					retArr.push('\n}\n');
-				}
-			}
-			return retArr;
-		}
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"base64-js":46,"ieee754":77,"isarray":80}],49:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astBreakStatement
-   *
-   * @desc Parses the abstract syntax tree for *Break* Statement
-   *
-   * @param {Object} brNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
 
-	}, {
-		key: 'astBreakStatement',
-		value: function astBreakStatement(brNode, retArr, funcParam) {
-			retArr.push('break;\n');
-			return retArr;
-		}
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astContinueStatement
-   *
-   * @desc Parses the abstract syntax tree for *Continue* Statement
-   *
-   * @param {Object} crNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
 
-	}, {
-		key: 'astContinueStatement',
-		value: function astContinueStatement(crNode, retArr, funcParam) {
-			retArr.push('continue;\n');
-			return retArr;
-		}
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astLogicalExpression
-   *
-   * @desc Parses the abstract syntax tree for *Logical* Expression
-   *
-   * @param {Object} logNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
 
-	}, {
-		key: 'astLogicalExpression',
-		value: function astLogicalExpression(logNode, retArr, funcParam) {
-			retArr.push('(');
-			this.astGeneric(logNode.left, retArr, funcParam);
-			retArr.push(logNode.operator);
-			this.astGeneric(logNode.right, retArr, funcParam);
-			retArr.push(')');
-			return retArr;
-		}
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astUpdateExpression
-   *
-   * @desc Parses the abstract syntax tree for *Update* Expression
-   *
-   * @param {Object} uNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
 
-	}, {
-		key: 'astUpdateExpression',
-		value: function astUpdateExpression(uNode, retArr, funcParam) {
-			if (uNode.prefix) {
-				retArr.push(uNode.operator);
-				this.astGeneric(uNode.argument, retArr, funcParam);
-			} else {
-				this.astGeneric(uNode.argument, retArr, funcParam);
-				retArr.push(uNode.operator);
-			}
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
 
-			return retArr;
-		}
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astUnaryExpression
-   *
-   * @desc Parses the abstract syntax tree for *Unary* Expression
-   *
-   * @param {Object} uNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isRegExp(re) {
+  return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
 
-	}, {
-		key: 'astUnaryExpression',
-		value: function astUnaryExpression(uNode, retArr, funcParam) {
-			if (uNode.prefix) {
-				retArr.push(uNode.operator);
-				this.astGeneric(uNode.argument, retArr, funcParam);
-			} else {
-				this.astGeneric(uNode.argument, retArr, funcParam);
-				retArr.push(uNode.operator);
-			}
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
 
-			return retArr;
-		}
+function isDate(d) {
+  return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astThisExpression
-   *
-   * @desc Parses the abstract syntax tree for *This* expression
-   *
-   * @param {Object} tNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isError(e) {
+  return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
 
-	}, {
-		key: 'astThisExpression',
-		value: function astThisExpression(tNode, retArr, funcParam) {
-			retArr.push('this');
-			return retArr;
-		}
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astMemberExpression
-   *
-   * @desc Parses the abstract syntax tree for *Member* Expression
-   *
-   * @param {Object} mNode - An ast Node
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
 
-	}, {
-		key: 'astMemberExpression',
-		value: function astMemberExpression(mNode, retArr, funcParam) {
-			if (mNode.computed) {
-				if (mNode.object.type === 'Identifier') {
-					// Working logger
-					var reqName = mNode.object.name;
-					var funcName = funcParam.functionName || 'kernel';
-					var assumeNotTexture = false;
+exports.isBuffer = Buffer.isBuffer;
 
-					// Possibly an array request - handle it as such
-					if (funcParam.paramNames) {
-						var idx = funcParam.paramNames.indexOf(reqName);
-						if (idx >= 0 && funcParam.paramTypes[idx] === 'float') {
-							assumeNotTexture = true;
-						}
-					}
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
 
-					if (assumeNotTexture) {
-						// Get from array
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('[int(');
-						this.astGeneric(mNode.property, retArr, funcParam);
-						retArr.push(')]');
-					} else {
-						// Get from texture
-						// This normally refers to the global read only input vars
-						retArr.push('get(');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push(', vec2(');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('Size[0],');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('Size[1]), vec3(');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('Dim[0],');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('Dim[1],');
-						this.astGeneric(mNode.object, retArr, funcParam);
-						retArr.push('Dim[2]');
-						retArr.push('), ');
-						this.astGeneric(mNode.property, retArr, funcParam);
-						retArr.push(')');
-					}
-				} else {
-					this.astGeneric(mNode.object, retArr, funcParam);
-					var last = retArr.pop();
-					retArr.push(',');
-					this.astGeneric(mNode.property, retArr, funcParam);
-					retArr.push(last);
-				}
-			} else {
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":79}],50:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-				// Unroll the member expression
-				var unrolled = this.astMemberExpressionUnroll(mNode);
-				var unrolled_lc = unrolled.toLowerCase();
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
 
-				// Its a constant, remove this.constants.
-				if (unrolled.indexOf(constantsPrefix) === 0) {
-					unrolled = 'constants_' + unrolled.slice(constantsPrefix.length);
-				}
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
 
-				switch (unrolled_lc) {
-					case 'this.thread.x':
-						retArr.push('threadId.x');
-						break;
-					case 'this.thread.y':
-						retArr.push('threadId.y');
-						break;
-					case 'this.thread.z':
-						retArr.push('threadId.z');
-						break;
-					case 'this.output.x':
-						retArr.push(this.output[0] + '.0');
-						break;
-					case 'this.output.y':
-						retArr.push(this.output[1] + '.0');
-						break;
-					case 'this.output.z':
-						retArr.push(this.output[2] + '.0');
-						break;
-					default:
-						retArr.push(unrolled);
-				}
-			}
-			return retArr;
-		}
-	}, {
-		key: 'astSequenceExpression',
-		value: function astSequenceExpression(sNode, retArr, funcParam) {
-			for (var i = 0; i < sNode.expressions.length; i++) {
-				if (i > 0) {
-					retArr.push(',');
-				}
-				this.astGeneric(sNode.expressions, retArr, funcParam);
-			}
-			return retArr;
-		}
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astCallExpression
-   *
-   * @desc Parses the abstract syntax tree for *call* expression
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns  {Array} the append retArr
-   */
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
 
-	}, {
-		key: 'astCallExpression',
-		value: function astCallExpression(ast, retArr, funcParam) {
-			if (ast.callee) {
-				// Get the full function call, unrolled
-				var funcName = this.astMemberExpressionUnroll(ast.callee);
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
 
-				// Its a math operator, remove the prefix
-				if (funcName.indexOf(jsMathPrefix) === 0) {
-					funcName = funcName.slice(jsMathPrefix.length);
-				}
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
 
-				// Its a local function, remove this
-				if (funcName.indexOf(localPrefix) === 0) {
-					funcName = funcName.slice(localPrefix.length);
-				}
+  if (!this._events)
+    this._events = {};
 
-				// Register the function into the called registry
-				if (funcParam.calledFunctions.indexOf(funcName) < 0) {
-					funcParam.calledFunctions.push(funcName);
-				}
-				if (!funcParam.hasOwnProperty('funcName')) {
-					funcParam.calledFunctionsArguments[funcName] = [];
-				}
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
+        // At least give some kind of context to the user
+        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+        err.context = er;
+        throw err;
+      }
+    }
+  }
 
-				var functionArguments = [];
-				funcParam.calledFunctionsArguments[funcName].push(functionArguments);
+  handler = this._events[type];
 
-				// Call the function
-				retArr.push(funcName);
+  if (isUndefined(handler))
+    return false;
 
-				// Open arguments space
-				retArr.push('(');
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        args = Array.prototype.slice.call(arguments, 1);
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    args = Array.prototype.slice.call(arguments, 1);
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
 
-				// Add the vars
-				for (var i = 0; i < ast.arguments.length; ++i) {
-					var argument = ast.arguments[i];
-					if (i > 0) {
-						retArr.push(', ');
-					}
-					this.astGeneric(argument, retArr, funcParam);
-					if (argument.type === 'Identifier') {
-						var paramIndex = funcParam.paramNames.indexOf(argument.name);
-						if (paramIndex === -1) {
-							functionArguments.push(null);
-						} else {
-							functionArguments.push({
-								name: argument.name,
-								type: funcParam.paramTypes[paramIndex]
-							});
-						}
-					} else {
-						functionArguments.push(null);
-					}
-				}
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
 
-				// Close arguments space
-				retArr.push(')');
+  if (!this._events)
+    this._events = {};
 
-				return retArr;
-			}
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
 
-			// Failure, unknown expression
-			throw this.astErrorOutput('Unknown CallExpression', ast, funcParam);
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
 
-			return retArr;
-		}
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name astArrayExpression
-   *
-   * @desc Parses the abstract syntax tree for *Array* Expression
-   *
-   * @param {Object} ast - the AST object to parse
-   * @param {Array} retArr - return array string
-   * @param {Function} funcParam - FunctionNode, that tracks compilation state
-   *
-   * @returns {Array} the append retArr
-   */
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
 
-	}, {
-		key: 'astArrayExpression',
-		value: function astArrayExpression(arrNode, retArr, funcParam) {
-			var arrLen = arrNode.elements.length;
+  return this;
+};
 
-			retArr.push('float[' + arrLen + '](');
-			for (var i = 0; i < arrLen; ++i) {
-				if (i > 0) {
-					retArr.push(', ');
-				}
-				var subNode = arrNode.elements[i];
-				this.astGeneric(subNode, retArr, funcParam);
-			}
-			retArr.push(')');
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-			return retArr;
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
 
-			// // Failure, unknown expression
-			// throw this.astErrorOutput(
-			// 	'Unknown  ArrayExpression',
-			// 	arrNode, funcParam
-			//);
-		}
+  var fired = false;
 
-		/**
-   * @memberOf WebGLFunctionNode#
-   * @function
-   * @name getFunctionPrototypeString
-   *
-   * @desc Returns the converted webgl shader function equivalent of the JS function
-   *
-   * @returns {String} webgl function string, result is cached under this.getFunctionPrototypeString
-   *
-   */
+  function g() {
+    this.removeListener(type, g);
 
-	}, {
-		key: 'getFunctionPrototypeString',
-		value: function getFunctionPrototypeString() {
-			if (this.webGlFunctionPrototypeString) {
-				return this.webGlFunctionPrototypeString;
-			}
-			return this.webGlFunctionPrototypeString = this.generate();
-		}
-	}, {
-		key: 'build',
-		value: function build() {
-			return this.getFunctionPrototypeString().length > 0;
-		}
-	}], [{
-		key: 'astFunctionPrototype',
-		value: function astFunctionPrototype(ast, retArr, funcParam) {
-			// Setup function return type and name
-			if (funcParam.isRootKernel || funcParam.isSubKernel) {
-				return retArr;
-			}
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
 
-			retArr.push(funcParam.returnType);
-			retArr.push(' ');
-			retArr.push(funcParam.functionName);
-			retArr.push('(');
+  g.listener = listener;
+  this.on(type, g);
 
-			// Arguments handling
-			for (var i = 0; i < funcParam.paramNames.length; ++i) {
-				if (i > 0) {
-					retArr.push(', ');
-				}
+  return this;
+};
 
-				retArr.push(funcParam.paramTypes[i]);
-				retArr.push(' ');
-				retArr.push('user_');
-				retArr.push(funcParam.paramNames[i]);
-			}
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
 
-			retArr.push(');\n');
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
 
-			return retArr;
-		}
-	}]);
+  if (!this._events || !this._events[type])
+    return this;
 
-	return WebGLFunctionNode;
-}(FunctionNodeBase);
+  list = this._events[type];
+  length = list.length;
+  position = -1;
 
-function isIdentifierKernelParam(paramName, ast, funcParam) {
-	return funcParam.paramNames.indexOf(paramName) !== -1;
-}
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
 
-function ensureIndentifierType(paramName, expectedType, ast, funcParam) {
-	var start = ast.loc.start;
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
 
-	if (!isIdentifierKernelParam(paramName, funcParam) && expectedType !== 'float') {
-		throw new Error('Error unexpected identifier ' + paramName + ' on line ' + start.line);
-	} else {
-		var actualType = funcParam.paramTypes[funcParam.paramNames.indexOf(paramName)];
-		if (actualType !== expectedType) {
-			throw new Error('Error unexpected identifier ' + paramName + ' on line ' + start.line);
-		}
-	}
-}
+    if (position < 0)
+      return this;
 
-/**
- * @ignore
- * @function
- * @name webgl_regex_optimize
- *
- * @desc [INTERNAL] Takes the near final webgl function string, and do regex search and replacments.
- * For voodoo optimize out the following: 
- *
- * - decode32(encode32( <br>
- * - encode32(decode32( <br>
- *
- * @param {String} inStr - The webGl function String
- *
- */
-function webGlRegexOptimize(inStr) {
-	return inStr.replace(DECODE32_ENCODE32, '((').replace(ENCODE32_DECODE32, '((');
-}
-},{"../../core/utils":74,"../function-node-base":56}],62:[function(require,module,exports){
-'use strict';
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
 
-var utils = require('../../core/utils');
-var kernelRunShortcut = require('../kernel-run-shortcut');
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
 
-module.exports = function (gpuKernel, name) {
-  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: function ' + utils.allPropertiesOf.toString() + ',\n      clone: function ' + utils.clone.toString() + ',\n      splitArray: function ' + utils.splitArray.toString() + ',\n      getArgumentType: function ' + utils.getArgumentType.toString() + ',\n      getDimensions: function ' + utils.getDimensions.toString() + ',\n      dimToTexSize: function ' + utils.dimToTexSize.toString() + ',\n      copyFlatten: function ' + utils.copyFlatten.toString() + ',\n      flatten: function ' + utils.flatten.toString() + ',\n      systemEndianness: \'' + utils.systemEndianness() + '\',\n      initWebGl: function ' + utils.initWebGl.toString() + ',\n      isArray: function ' + utils.isArray.toString() + '\n    };\n    class ' + (name || 'Kernel') + ' {\n      constructor() {\n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = ' + JSON.stringify(gpuKernel.paramNames) + ';\n        this.paramTypes = ' + JSON.stringify(gpuKernel.paramTypes) + ';\n        this.texSize = ' + JSON.stringify(gpuKernel.texSize) + ';\n        this.output = ' + JSON.stringify(gpuKernel.output) + ';\n        this.compiledFragShaderString = `' + gpuKernel.compiledFragShaderString + '`;\n\t\t    this.compiledVertShaderString = `' + gpuKernel.compiledVertShaderString + '`;\n\t\t    this.programUniformLocationCache = {};\n\t\t    this.textureCache = {};\n\t\t    this.subKernelOutputTextures = null;\n      }\n      ' + gpuKernel._getFragShaderString.toString() + '\n      ' + gpuKernel._getVertShaderString.toString() + '\n      validateOptions() {}\n      setupParams() {}\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      ' + gpuKernel.getUniformLocation.toString() + '\n      ' + gpuKernel.setupParams.toString() + '\n      ' + gpuKernel.build.toString() + '\n\t\t  ' + gpuKernel.run.toString() + '\n\t\t  ' + gpuKernel._addArgument.toString() + '\n\t\t  ' + gpuKernel.getArgumentTexture.toString() + '\n\t\t  ' + gpuKernel.getTextureCache.toString() + '\n\t\t  ' + gpuKernel.getOutputTexture.toString() + '\n\t\t  ' + gpuKernel.renderOutput.toString() + '\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
+  return this;
 };
-},{"../../core/utils":74,"../kernel-run-shortcut":58}],63:[function(require,module,exports){
-'use strict';
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  if (!this._events)
+    return this;
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else if (listeners) {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
 
-var KernelBase = require('../kernel-base');
-var utils = require('../../core/utils');
-var Texture = require('../../core/texture');
-var fragShaderString = require('./shader-frag');
-var vertShaderString = require('./shader-vert');
-var kernelString = require('./kernel-string');
-var canvases = [];
-var maxTexSizes = {};
+  return this;
+};
 
-module.exports = function (_KernelBase) {
-	_inherits(WebGLKernel, _KernelBase);
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
 
-	/**
-  * @constructor WebGLKernel
-  *
-  * @desc Kernel Implementation for WebGL.
-  * <p>This builds the shaders and runs them on the GPU,
-  * the outputs the result back as float(enabled by default) and Texture.</p>
-  *
-  * @extends KernelBase
-  *
-  * @prop {Object} textureCache - webGl Texture cache
-  * @prop {Object} threadDim - The thread dimensions, x, y and z
-  * @prop {Object} programUniformLocationCache - Location of program variables in memory
-  * @prop {Object} framebuffer - Webgl frameBuffer
-  * @prop {Object} buffer - WebGL buffer
-  * @prop {Object} program - The webGl Program
-  * @prop {Object} functionBuilder - Function Builder instance bound to this Kernel
-  * @prop {Boolean} outputToTexture - Set output type to Texture, instead of float
-  * @prop {String} endianness - Endian information like Little-endian, Big-endian.
-  * @prop {Array} paramTypes - Types of parameters sent to the Kernel
-  * @prop {number} argumentsLength - Number of parameters sent to the Kernel
-  * @prop {String} compiledFragShaderString - Compiled fragment shader string
-  * @prop {String} compiledVertShaderString - Compiled Vertical shader string
-  */
-	function WebGLKernel(fnString, settings) {
-		_classCallCheck(this, WebGLKernel);
+EventEmitter.prototype.listenerCount = function(type) {
+  if (this._events) {
+    var evlistener = this._events[type];
 
-		var _this = _possibleConstructorReturn(this, (WebGLKernel.__proto__ || Object.getPrototypeOf(WebGLKernel)).call(this, fnString, settings));
+    if (isFunction(evlistener))
+      return 1;
+    else if (evlistener)
+      return evlistener.length;
+  }
+  return 0;
+};
 
-		_this.textureCache = {};
-		_this.threadDim = {};
-		_this.programUniformLocationCache = {};
-		_this.framebuffer = null;
+EventEmitter.listenerCount = function(emitter, type) {
+  return emitter.listenerCount(type);
+};
 
-		_this.buffer = null;
-		_this.program = null;
-		_this.outputToTexture = settings.outputToTexture;
-		_this.endianness = utils.systemEndianness();
-		_this.subKernelOutputTextures = null;
-		_this.subKernelOutputVariableNames = null;
-		_this.argumentsLength = 0;
-		_this.ext = null;
-		_this.compiledFragShaderString = null;
-		_this.compiledVertShaderString = null;
-		_this.extDrawBuffersMap = null;
-		_this.outputTexture = null;
-		_this.maxTexSize = null;
-		if (!_this._webGl) _this._webGl = utils.initWebGl(_this.getCanvas());
-		return _this;
-	}
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
 
-	/**
-  * @memberOf WebGLKernel#
-  * @function
-  * @name validateOptions
-  *
-  * @desc Validate options related to Kernel, such as
-  * floatOutputs and Textures, texSize, output,
-  * graphical output.
-  *
-  */
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
 
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
 
-	_createClass(WebGLKernel, [{
-		key: 'validateOptions',
-		value: function validateOptions() {
-			var isFloatReadPixel = utils.isFloatReadPixelsSupported();
-			if (this.floatTextures === true && !utils.OES_texture_float) {
-				throw new Error('Float textures are not supported on this browser');
-			} else if (this.floatOutput === true && this.floatOutputForce !== true && !isFloatReadPixel) {
-				throw new Error('Float texture outputs are not supported on this browser');
-			} else if (this.floatTextures === undefined && utils.OES_texture_float) {
-				this.floatTextures = true;
-				this.floatOutput = isFloatReadPixel;
-			}
+function isUndefined(arg) {
+  return arg === void 0;
+}
 
-			if (!this.output || this.output.length === 0) {
-				if (arguments.length !== 1) {
-					throw new Error('Auto output only supported for kernels with only one input');
-				}
+},{}],51:[function(require,module,exports){
+'use strict';
 
-				var argType = utils.getArgumentType(arguments[0]);
-				if (argType === 'Array') {
-					this.output = utils.getDimensions(argType);
-				} else if (argType === 'Texture') {
-					this.output = arguments[0].output;
-				} else {
-					throw new Error('Auto output not supported for input type: ' + argType);
-				}
-			}
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-			this.texSize = utils.dimToTexSize({
-				floatTextures: this.floatTextures,
-				floatOutput: this.floatOutput
-			}, this.output, true);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-			if (this.graphical) {
-				if (this.output.length !== 2) {
-					throw new Error('Output must have 2 dimensions on graphical mode');
-				}
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-				if (this.floatOutput) {
-					this.floatOutput = false;
-					console.warn('Cannot use graphical mode and float output at the same time');
-				}
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-				this.texSize = utils.clone(this.output);
-			} else if (this.floatOutput === undefined && utils.OES_texture_float) {
-				this.floatOutput = true;
-			}
-		}
-	}, {
-		key: 'updateMaxTexSize',
-		value: function updateMaxTexSize() {
-			var texSize = this.texSize;
-			var canvas = this._canvas;
-			if (this.maxTexSize === null) {
-				var canvasIndex = canvases.indexOf(canvas);
-				if (canvasIndex === -1) {
-					canvasIndex = canvases.length;
-					canvases.push(canvas);
-					maxTexSizes[canvasIndex] = [texSize[0], texSize[1]];
-				}
-				this.maxTexSize = maxTexSizes[canvasIndex];
-			}
-			if (this.maxTexSize[0] < texSize[0]) {
-				this.maxTexSize[0] = texSize[0];
-			}
-			if (this.maxTexSize[1] < texSize[1]) {
-				this.maxTexSize[1] = texSize[1];
-			}
-		}
+var FunctionBuilderBase = require('../function-builder-base');
+var CPUFunctionNode = require('./function-node');
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name build
-   *
-   * @desc Builds the Kernel, by compiling Fragment and Vertical Shaders,
-   * and instantiates the program.
-   *
-   */
+/**
+ * @class CPUFunctionBuilder
+ *
+ * @extends FunctionBuilderBase
+ *
+ * @desc Builds functions to execute on CPU from JavaScript function Strings
+ *
+ */
+module.exports = function (_FunctionBuilderBase) {
+  _inherits(CPUFunctionBuilder, _FunctionBuilderBase);
 
-	}, {
-		key: 'build',
-		value: function build() {
-			this.validateOptions();
-			this.setupParams(arguments);
-			this.updateMaxTexSize();
-			var texSize = this.texSize;
-			var gl = this._webGl;
-			var canvas = this._canvas;
-			gl.enable(gl.SCISSOR_TEST);
-			gl.viewport(0, 0, this.maxTexSize[0], this.maxTexSize[1]);
-			canvas.width = this.maxTexSize[0];
-			canvas.height = this.maxTexSize[1];
-			var threadDim = this.threadDim = utils.clone(this.output);
-			while (threadDim.length < 3) {
-				threadDim.push(1);
-			}
+  function CPUFunctionBuilder() {
+    _classCallCheck(this, CPUFunctionBuilder);
 
-			if (this.functionBuilder) this._addKernels();
+    var _this = _possibleConstructorReturn(this, (CPUFunctionBuilder.__proto__ || Object.getPrototypeOf(CPUFunctionBuilder)).call(this));
 
-			var compiledVertShaderString = this._getVertShaderString(arguments);
-			var vertShader = gl.createShader(gl.VERTEX_SHADER);
-			gl.shaderSource(vertShader, compiledVertShaderString);
-			gl.compileShader(vertShader);
+    _this.Node = CPUFunctionNode;
+    return _this;
+  }
 
-			var compiledFragShaderString = this._getFragShaderString(arguments);
-			var fragShader = gl.createShader(gl.FRAGMENT_SHADER);
-			gl.shaderSource(fragShader, compiledFragShaderString);
-			gl.compileShader(fragShader);
+  _createClass(CPUFunctionBuilder, [{
+    key: 'polyfillStandardFunctions',
+    value: function polyfillStandardFunctions() {}
+  }]);
 
-			if (!gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)) {
-				console.log(compiledVertShaderString);
-				console.error('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(vertShader));
-				throw new Error('Error compiling vertex shader');
-			}
-			if (!gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)) {
-				console.log(compiledFragShaderString);
-				console.error('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(fragShader));
-				throw new Error('Error compiling fragment shader');
-			}
+  return CPUFunctionBuilder;
+}(FunctionBuilderBase);
+},{"../function-builder-base":56,"./function-node":52}],52:[function(require,module,exports){
+'use strict';
 
-			if (this.debug) {
-				console.log('Options:');
-				console.dir(this);
-				console.log('GLSL Shader Output:');
-				console.log(compiledFragShaderString);
-			}
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-			var program = this.program = gl.createProgram();
-			gl.attachShader(program, vertShader);
-			gl.attachShader(program, fragShader);
-			gl.linkProgram(program);
-			this.framebuffer = gl.createFramebuffer();
-			this.framebuffer.width = texSize[0];
-			this.framebuffer.height = texSize[1];
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-			var vertices = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
-			var texCoords = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-			var texCoordOffset = vertices.byteLength;
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-			var buffer = this.buffer;
-			if (!buffer) {
-				buffer = this.buffer = gl.createBuffer();
-				gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-				gl.bufferData(gl.ARRAY_BUFFER, vertices.byteLength + texCoords.byteLength, gl.STATIC_DRAW);
-			} else {
-				gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-			}
+var BaseFunctionNode = require('../function-node-base');
+var utils = require('../../core/utils');
 
-			gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
-			gl.bufferSubData(gl.ARRAY_BUFFER, texCoordOffset, texCoords);
+/**
+ * @class CPUFunctionNode
+ * 
+ * @extends BaseFunctionNode
+ *
+ * @desc [INTERNAL] Represents a single function, inside JS
+ *
+ * <p>This handles all the raw state, converted state, etc. Of a single function.</p>
+ *
+ * @prop functionName         - {String}        Name of the function
+ * @prop jsFunction           - {Function}   The JS Function the node represents
+ * @prop jsFunctionString     - {String}        jsFunction.toString()
+ * @prop paramNames           - {String[]}  Parameter names of the function
+ * @prop paramTypes           - {String[]}  Shader land parameters type assumption
+ * @prop isRootKernel         - {Boolean}       Special indicator, for kernel function
+ * @prop webglFunctionString  - {String}        webgl converted function string
+ * @prop openglFunctionString - {String}        opengl converted function string
+ * @prop calledFunctions      - {String[]}  List of all the functions called
+ * @prop initVariables        - {String[]}  List of variables initialized in the function
+ * @prop readVariables        - {String[]}  List of variables read operations occur
+ * @prop writeVariables       - {String[]}  List of variables write operations occur
+ *
+ */
+module.exports = function (_BaseFunctionNode) {
+	_inherits(CPUFunctionNode, _BaseFunctionNode);
 
-			var aPosLoc = gl.getAttribLocation(this.program, 'aPos');
-			gl.enableVertexAttribArray(aPosLoc);
-			gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, gl.FALSE, 0, 0);
-			var aTexCoordLoc = gl.getAttribLocation(this.program, 'aTexCoord');
-			gl.enableVertexAttribArray(aTexCoordLoc);
-			gl.vertexAttribPointer(aTexCoordLoc, 2, gl.FLOAT, gl.FALSE, 0, texCoordOffset);
+	function CPUFunctionNode() {
+		_classCallCheck(this, CPUFunctionNode);
 
-			this.setupOutputTexture();
+		return _possibleConstructorReturn(this, (CPUFunctionNode.__proto__ || Object.getPrototypeOf(CPUFunctionNode)).apply(this, arguments));
+	}
 
-			if (this.subKernelOutputTextures !== null) {
-				var extDrawBuffersMap = this.extDrawBuffersMap = [gl.COLOR_ATTACHMENT0];
-				for (var i = 0; i < this.subKernelOutputTextures.length; i++) {
-					var subKernelOutputTexture = this.subKernelOutputTextures[i];
-					extDrawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
-					gl.activeTexture(gl.TEXTURE0 + arguments.length + i);
-					gl.bindTexture(gl.TEXTURE_2D, subKernelOutputTexture);
-					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-					if (this.floatOutput) {
-						gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
-					} else {
-						gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-					}
-				}
+	_createClass(CPUFunctionNode, [{
+		key: 'generate',
+		value: function generate() {
+			if (this.debug) {
+				console.log(this);
 			}
+			this.functionStringArray = this.astGeneric(this.getJsAST(), [], this);
+			this.functionString = this.functionStringArray.join('').trim();
+			return this.functionString;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf CPUFunctionNode#
    * @function
-   * @name run
-   *
-   * @desc Run the kernel program, and send the output to renderOutput
-   *
-   * <p> This method calls a helper method *renderOutput* to return the result. </p>
+   * @name getFunctionPrototypeString
    *
-   * @returns {Object} Result The final output of the program, as float, and as Textures for reuse.
+   * @desc Returns the converted JS function
    *
+   * @returns {String} function string, result is cached under this.getFunctionPrototypeString
    *
    */
 
 	}, {
-		key: 'run',
-		value: function run() {
-			if (this.program === null) {
-				this.build.apply(this, arguments);
-			}
-			var paramNames = this.paramNames;
-			var paramTypes = this.paramTypes;
-			var texSize = this.texSize;
-			var gl = this._webGl;
-
-			gl.useProgram(this.program);
-			gl.scissor(0, 0, texSize[0], texSize[1]);
-
-			if (!this.hardcodeConstants) {
-				var uOutputDimLoc = this.getUniformLocation('uOutputDim');
-				gl.uniform3fv(uOutputDimLoc, this.threadDim);
-				var uTexSizeLoc = this.getUniformLocation('uTexSize');
-				gl.uniform2fv(uTexSizeLoc, texSize);
-			}
-
-			var ratioLoc = this.getUniformLocation('ratio');
-			gl.uniform2f(ratioLoc, texSize[0] / this.maxTexSize[0], texSize[1] / this.maxTexSize[1]);
-
-			this.argumentsLength = 0;
-			for (var texIndex = 0; texIndex < paramNames.length; texIndex++) {
-				this._addArgument(arguments[texIndex], paramTypes[texIndex], paramNames[texIndex]);
-			}
-
-			if (this.graphical) {
-				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
-				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-				return;
-			}
-
-			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
-			//the call to this._addArgument may rewrite the outputTexture, keep this here
-			var outputTexture = this.outputTexture;
-			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
-
-			if (this.subKernelOutputTextures !== null) {
-				for (var i = 0; i < this.subKernelOutputTextures.length; i++) {
-					var subKernelOutputTexture = this.subKernelOutputTextures[i];
-					gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, subKernelOutputTexture, 0);
-				}
-				this.ext.drawBuffersWEBGL(this.extDrawBuffersMap);
-			}
-
-			gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-
-			if (this.subKernelOutputTextures !== null) {
-				if (this.subKernels !== null) {
-					var output = [];
-					output.result = this.renderOutput(outputTexture);
-					for (var _i = 0; _i < this.subKernels.length; _i++) {
-						output.push(new Texture(this.subKernelOutputTextures[_i], texSize, this.output, this._webGl));
-					}
-					return output;
-				} else if (this.subKernelProperties !== null) {
-					var _output = {
-						result: this.renderOutput(outputTexture)
-					};
-					var _i2 = 0;
-					for (var p in this.subKernelProperties) {
-						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
-						_output[p] = new Texture(this.subKernelOutputTextures[_i2], texSize, this.output, this._webGl);
-						_i2++;
-					}
-					return _output;
-				}
+		key: 'getFunctionPrototypeString',
+		value: function getFunctionPrototypeString() {
+			if (this.webGlFunctionPrototypeString) {
+				return this.webGlFunctionPrototypeString;
 			}
-
-			return this.renderOutput(outputTexture);
+			return this.webGlFunctionPrototypeString = this.generate();
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name renderOutput
-   *
-   *
-   * @desc Helper function to return webGl function's output.
-   * Since the program runs on GPU, we need to get the
-   * output of the program back to CPU and then return them.
-   *
-   * *Note*: This should not be called directly.
-   *
-   * @param {Object} outputTexture - Output Texture returned by webGl program
+   * @name astGeneric
    *
-   * @returns {Object|Array} result
+   * @desc Parses the abstract syntax tree for generically to its respective function
    *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the parsed cpu string array
    */
 
 	}, {
-		key: 'renderOutput',
-		value: function renderOutput(outputTexture) {
-			var texSize = this.texSize;
-			var gl = this._webGl;
-			var threadDim = this.threadDim;
-			var output = this.output;
-			if (this.outputToTexture) {
-				return new Texture(outputTexture, texSize, output, this._webGl);
+		key: 'astGeneric',
+		value: function astGeneric(ast, retArr, funcParam) {
+			if (ast === null) {
+				throw this.astErrorOutput('NULL ast', ast, funcParam);
 			} else {
-				var result = void 0;
-				if (this.floatOutput) {
-					result = new Float32Array(texSize[0] * texSize[1] * 4);
-					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.FLOAT, result);
-				} else {
-					var bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
-					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
-					result = new Float32Array(bytes.buffer);
+				if (Array.isArray(ast)) {
+					for (var i = 0; i < ast.length; i++) {
+						this.astGeneric(ast[i], retArr, funcParam);
+					}
+					return retArr;
+				}
+
+				switch (ast.type) {
+					case 'FunctionDeclaration':
+						return this.astFunctionDeclaration(ast, retArr, funcParam);
+					case 'FunctionExpression':
+						return this.astFunctionExpression(ast, retArr, funcParam);
+					case 'ReturnStatement':
+						return this.astReturnStatement(ast, retArr, funcParam);
+					case 'Literal':
+						return this.astLiteral(ast, retArr, funcParam);
+					case 'BinaryExpression':
+						return this.astBinaryExpression(ast, retArr, funcParam);
+					case 'Identifier':
+						return this.astIdentifierExpression(ast, retArr, funcParam);
+					case 'AssignmentExpression':
+						return this.astAssignmentExpression(ast, retArr, funcParam);
+					case 'ExpressionStatement':
+						return this.astExpressionStatement(ast, retArr, funcParam);
+					case 'EmptyStatement':
+						return this.astEmptyStatement(ast, retArr, funcParam);
+					case 'BlockStatement':
+						return this.astBlockStatement(ast, retArr, funcParam);
+					case 'IfStatement':
+						return this.astIfStatement(ast, retArr, funcParam);
+					case 'BreakStatement':
+						return this.astBreakStatement(ast, retArr, funcParam);
+					case 'ContinueStatement':
+						return this.astContinueStatement(ast, retArr, funcParam);
+					case 'ForStatement':
+						return this.astForStatement(ast, retArr, funcParam);
+					case 'WhileStatement':
+						return this.astWhileStatement(ast, retArr, funcParam);
+					case 'VariableDeclaration':
+						return this.astVariableDeclaration(ast, retArr, funcParam);
+					case 'VariableDeclarator':
+						return this.astVariableDeclarator(ast, retArr, funcParam);
+					case 'ThisExpression':
+						return this.astThisExpression(ast, retArr, funcParam);
+					case 'SequenceExpression':
+						return this.astSequenceExpression(ast, retArr, funcParam);
+					case 'UnaryExpression':
+						return this.astUnaryExpression(ast, retArr, funcParam);
+					case 'UpdateExpression':
+						return this.astUpdateExpression(ast, retArr, funcParam);
+					case 'LogicalExpression':
+						return this.astLogicalExpression(ast, retArr, funcParam);
+					case 'MemberExpression':
+						return this.astMemberExpression(ast, retArr, funcParam);
+					case 'CallExpression':
+						return this.astCallExpression(ast, retArr, funcParam);
+					case 'ArrayExpression':
+						return this.astArrayExpression(ast, retArr, funcParam);
+					case 'DebuggerStatement':
+						return this.astDebuggerStatement(ast, retArr, funcParam);
 				}
 
-				result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
-
-				if (output.length === 1) {
-					return result;
-				} else if (output.length === 2) {
-					return utils.splitArray(result, output[0]);
-				} else if (output.length === 3) {
-					var cube = utils.splitArray(result, output[0] * output[1]);
-					return cube.map(function (x) {
-						return utils.splitArray(x, output[0]);
-					});
-				}
+				throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast, funcParam);
 			}
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name getOutputTexture
+   * @name astFunctionDeclaration
    *
-   * @desc This uses *getTextureCache* to get the Texture Cache of the Output
+   * @desc Parses the abstract syntax tree for to its *named function declaration*
    *
-   * @returns {Object} Ouptut Texture Cache
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: 'getOutputTexture',
-		value: function getOutputTexture() {
-			return this.getTextureCache('OUTPUT');
+		key: 'astFunctionDeclaration',
+		value: function astFunctionDeclaration(ast, retArr, funcParam) {
+			if (this.addFunction) {
+				this.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
+			}
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name detachOutputTexture
+   * @name astFunctionPrototype
+   * @static
    *
-   * @desc Detaches output texture
+   * @desc Parses the abstract syntax tree for to its *named function prototype*
    *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: 'detachOutputTexture',
-		value: function detachOutputTexture() {
-			this.detachTextureCache('OUTPUT');
-		}
-
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name setupOutputTexture
-   *
-   * @desc Detaches a texture from cache if exists, and sets up output texture
-   */
+		key: 'astFunctionExpression',
 
-	}, {
-		key: 'setupOutputTexture',
-		value: function setupOutputTexture() {
-			var gl = this._webGl;
-			var texSize = this.texSize;
-			this.detachOutputTexture();
-			this.outputTexture = this.getOutputTexture();
-			gl.activeTexture(gl.TEXTURE0 + this.paramNames.length);
-			gl.bindTexture(gl.TEXTURE_2D, this.outputTexture);
-			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-			if (this.floatOutput) {
-				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
-			} else {
-				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-			}
-		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name getArgumentTexture
-   *
-   * @desc This uses *getTextureCache** to get the Texture Cache of the argument supplied
+   * @name astFunctionExpression
    *
-   * @param {String} name - Name of the argument
+   * @desc Parses the abstract syntax tree for to its *named function*
    *
-   * 	Texture cache for the supplied argument
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
+		value: function astFunctionExpression(ast, retArr, funcParam) {
 
-	}, {
-		key: 'getArgumentTexture',
-		value: function getArgumentTexture(name) {
-			return this.getTextureCache('ARGUMENT_' + name);
+			// Setup function return type and name
+			if (!funcParam.isRootKernel) {
+				retArr.push('function');
+				funcParam.kernalAst = ast;
+				retArr.push(' ');
+				retArr.push(funcParam.functionName);
+				retArr.push('(');
+
+				// Arguments handling
+				for (var i = 0; i < funcParam.paramNames.length; ++i) {
+					var paramName = funcParam.paramNames[i];
+
+					if (i > 0) {
+						retArr.push(', ');
+					}
+
+					retArr.push(' ');
+					retArr.push('user_');
+					retArr.push(paramName);
+				}
+
+				// Function opening
+				retArr.push(') {\n');
+			}
+
+			// Body statement iteration
+			for (var _i = 0; _i < ast.body.body.length; ++_i) {
+				this.astGeneric(ast.body.body[_i], retArr, funcParam);
+				retArr.push('\n');
+			}
+
+			if (!funcParam.isRootKernel) {
+				// Function closing
+				retArr.push('}\n');
+			}
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
-   * @name getSubKernelTexture
+   * @memberOf WebGLFunctionNode#
    * @function
+   * @name astReturnStatement
    *
-   * @desc This uses *getTextureCache* to get the Texture Cache of the sub-kernel
-   *
-   * @param {String} name - Name of the subKernel
+   * @desc Parses the abstract syntax tree for to *return* statement
    *
-   * @returns {Object} Texture cache for the subKernel
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Object} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: 'getSubKernelTexture',
-		value: function getSubKernelTexture(name) {
-			return this.getTextureCache('SUB_KERNEL_' + name);
+		key: 'astReturnStatement',
+		value: function astReturnStatement(ast, retArr, funcParam) {
+			if (funcParam.isRootKernel) {
+				retArr.push('kernelResult = ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+			} else if (funcParam.isSubKernel) {
+				retArr.push(funcParam.functionName + 'Result = ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+				retArr.push('return ' + funcParam.functionName + 'Result;');
+			} else {
+				retArr.push('return ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+			}
+
+			//throw this.astErrorOutput(
+			//	'Non main function return, is not supported : '+funcParam.currentFunctionNamespace,
+			//	ast, funcParam
+			//);
+
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
-   * @name getTextureCache
+   * @memberOf WebGLFunctionNode#
    * @function
+   * @name astLiteral
    *
-   * @desc Returns the Texture Cache of the supplied parameter (can be kernel, sub-kernel or argument)
-   *
-   * @param {String} name - Name of the subkernel, argument, or kernel.
+   * @desc Parses the abstract syntax tree for *literal value*
    *
-   * @returns {Object} Texture cache
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: 'getTextureCache',
-		value: function getTextureCache(name) {
-			if (this.outputToTexture) {
-				// Don't retain a handle on the output texture, we might need to render on the same texture later
-				return this._webGl.createTexture();
-			}
-			if (this.textureCache.hasOwnProperty(name)) {
-				return this.textureCache[name];
+		key: 'astLiteral',
+		value: function astLiteral(ast, retArr, funcParam) {
+
+			// Reject non numeric literals
+			if (isNaN(ast.value)) {
+				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast, funcParam);
 			}
-			return this.textureCache[name] = this._webGl.createTexture();
-		}
 
-		/**
-   * @memberOf WebGLKernel#
-   * @name detachTextureCache
-   * @function
-   * @desc removes a texture from the kernel's cache
-   * @param {String} name - Name of texture
-   */
+			retArr.push(ast.value);
 
-	}, {
-		key: 'detachTextureCache',
-		value: function detachTextureCache(name) {
-			delete this.textureCache[name];
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name getUniformLocation
+   * @name astBinaryExpression
    *
-   * @desc Return WebGlUniformLocation for various variables
-   * related to webGl program, such as user-defiend variables,
-   * as well as, dimension sizes, etc.
+   * @desc Parses the abstract syntax tree for *binary* expression
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: 'getUniformLocation',
-		value: function getUniformLocation(name) {
-			var location = this.programUniformLocationCache[name];
-			if (!location) {
-				location = this._webGl.getUniformLocation(this.program, name);
-				this.programUniformLocationCache[name] = location;
-			}
-			return location;
+		key: 'astBinaryExpression',
+		value: function astBinaryExpression(ast, retArr, funcParam) {
+			retArr.push('(');
+			this.astGeneric(ast.left, retArr, funcParam);
+			retArr.push(ast.operator);
+			this.astGeneric(ast.right, retArr, funcParam);
+			retArr.push(')');
+			return retArr;
 		}
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getFragShaderArtifactMap
-   *
-   * @desc Generate Shader artifacts for the kernel program.
-   * The final object contains HEADER, KERNEL, MAIN_RESULT, and others.
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astIdentifierExpression
    *
-   * @param {Array} args - The actual parameters sent to the Kernel
+   * @desc Parses the abstract syntax tree for *identifier* expression
    *
-   * @returns {Object} An object containing the Shader Artifacts(CONSTANTS, HEADER, KERNEL, etc.)
+   * @param {Object} idtNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getFragShaderArtifactMap',
-		value: function _getFragShaderArtifactMap(args) {
-			return {
-				HEADER: this._getHeaderString(),
-				LOOP_MAX: this._getLoopMaxString(),
-				CONSTANTS: this._getConstantsString(),
-				DECODE32_ENDIANNESS: this._getDecode32EndiannessString(),
-				ENCODE32_ENDIANNESS: this._getEncode32EndiannessString(),
-				GET_WRAPAROUND: this._getGetWraparoundString(),
-				GET_TEXTURE_CHANNEL: this._getGetTextureChannelString(),
-				GET_TEXTURE_INDEX: this._getGetTextureIndexString(),
-				GET_RESULT: this._getGetResultString(),
-				MAIN_PARAMS: this._getMainParamsString(args),
-				MAIN_CONSTANTS: this._getMainConstantsString(),
-				KERNEL: this._getKernelString(),
-				MAIN_RESULT: this._getMainResultString()
-			};
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(idtNode, retArr, funcParam) {
+			if (idtNode.type !== 'Identifier') {
+				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode, funcParam);
+			}
+
+			switch (idtNode.name) {
+				case 'gpu_threadX':
+					retArr.push('threadId.x');
+					break;
+				case 'gpu_threadY':
+					retArr.push('threadId.y');
+					break;
+				case 'gpu_threadZ':
+					retArr.push('threadId.z');
+					break;
+				case 'gpu_outputX':
+					retArr.push('uOutputDim.x');
+					break;
+				case 'gpu_outputY':
+					retArr.push('uOutputDim.y');
+					break;
+				case 'gpu_outputZ':
+					retArr.push('uOutputDim.z');
+					break;
+				default:
+					if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
+						retArr.push('constants_' + idtNode.name);
+					} else {
+						var userParamName = funcParam.getUserParamName(idtNode.name);
+						if (userParamName !== null) {
+							retArr.push('user_' + userParamName);
+						} else {
+							retArr.push('user_' + idtNode.name);
+						}
+					}
+			}
+
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _addArgument
+   * @name astForStatement
    *
-   * @desc Adds kernel parameters to the Argument Texture,
-   * binding it to the webGl instance, etc.
+   * @desc Parses the abstract syntax tree forfor *for-loop* expression
    *
-   * @param {Array|Texture|Number} value - The actual argument supplied to the kernel
-   * @param {String} type - Type of the argument
-   * @param {String} name - Name of the argument
+   * @param {Object} forNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the parsed cpu string
    */
 
 	}, {
-		key: '_addArgument',
-		value: function _addArgument(value, type, name) {
-			var gl = this._webGl;
-			var argumentTexture = this.getArgumentTexture(name);
-			if (value instanceof Texture) {
-				type = 'Texture';
+		key: 'astForStatement',
+		value: function astForStatement(forNode, retArr, funcParam) {
+			if (forNode.type !== 'ForStatement') {
+				throw this.astErrorOutput('Invalid for statment', forNode, funcParam);
 			}
-			switch (type) {
-				case 'Array':
-					{
-						var dim = utils.getDimensions(value, true);
-						var size = utils.dimToTexSize({
-							floatTextures: this.floatTextures,
-							floatOutput: this.floatOutput
-						}, dim);
-						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
-						gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-
-						var length = size[0] * size[1];
-						if (this.floatTextures) {
-							length *= 4;
-						}
-
-						var valuesFlat = new Float32Array(length);
-						utils.flattenTo(value, valuesFlat);
-
-						var buffer = void 0;
-						if (this.floatTextures) {
-							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
-						} else {
-							buffer = new Uint8Array(valuesFlat.buffer);
-							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
-						}
 
-						var loc = this.getUniformLocation('user_' + name);
-						var locSize = this.getUniformLocation('user_' + name + 'Size');
-						var dimLoc = this.getUniformLocation('user_' + name + 'Dim');
+			if (forNode.test && forNode.test.type === 'BinaryExpression') {
+				if ((forNode.test.right.type === 'Identifier' || forNode.test.right.type === 'Literal') && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {
 
-						if (!this.hardcodeConstants) {
-							gl.uniform3fv(dimLoc, dim);
-							gl.uniform2fv(locSize, size);
-						}
-						gl.uniform1i(loc, this.argumentsLength);
-						break;
-					}
-				case 'Number':
-					{
-						var _loc = this.getUniformLocation('user_' + name);
-						gl.uniform1f(_loc, value);
-						break;
+					if (!this.loopMaxIterations) {
+						console.warn('Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior.');
+						console.warn('Set loopMaxIterations or use a for loop of fixed length to silence this message.');
 					}
-				case 'Input':
-					{
-						var input = value;
-						var _dim = input.size;
-						var _size = utils.dimToTexSize({
-							floatTextures: this.floatTextures,
-							floatOutput: this.floatOutput
-						}, _dim);
-						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
-						gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-
-						var _length = _size[0] * _size[1];
-						var inputArray = void 0;
-						if (this.floatTextures) {
-							_length *= 4;
-							inputArray = new Float32Array(_length);
-							inputArray.set(input.value);
-						} else {
-							inputArray = input.value;
-						}
-
-						if (this.floatTextures) {
-							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0], _size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
-						} else {
-							var _buffer = new Uint8Array(inputArray.buffer);
-							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0], _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
-						}
-
-						var _loc2 = this.getUniformLocation('user_' + name);
-						var _locSize = this.getUniformLocation('user_' + name + 'Size');
-						var _dimLoc = this.getUniformLocation('user_' + name + 'Dim');
 
-						if (!this.hardcodeConstants) {
-							gl.uniform3fv(_dimLoc, _dim);
-							gl.uniform2fv(_locSize, _size);
-						}
-						gl.uniform1i(_loc2, this.argumentsLength);
-						break;
+					retArr.push('for (');
+					this.astGeneric(forNode.init, retArr, funcParam);
+					if (retArr[retArr.length - 1] !== ';') {
+						retArr.push(';');
 					}
-				case 'Texture':
-					{
-						var inputTexture = value;
-						var _dim2 = utils.getDimensions(inputTexture, true);
-
-						var _size2 = inputTexture.size;
+					this.astGeneric(forNode.test.left, retArr, funcParam);
+					retArr.push(forNode.test.operator);
+					retArr.push('LOOP_MAX');
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr, funcParam);
+					retArr.push(')');
 
-						if (inputTexture.texture === this.outputTexture) {
-							this.setupOutputTexture();
+					retArr.push('{\n');
+					retArr.push('if (');
+					this.astGeneric(forNode.test.left, retArr, funcParam);
+					retArr.push(forNode.test.operator);
+					this.astGeneric(forNode.test.right, retArr, funcParam);
+					retArr.push(') {\n');
+					if (forNode.body.type === 'BlockStatement') {
+						for (var i = 0; i < forNode.body.body.length; i++) {
+							this.astGeneric(forNode.body.body[i], retArr, funcParam);
 						}
+					} else {
+						this.astGeneric(forNode.body, retArr, funcParam);
+					}
+					retArr.push('} else {\n');
+					retArr.push('break;\n');
+					retArr.push('}\n');
+					retArr.push('}\n');
 
-						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
-						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
-
-						var _loc3 = this.getUniformLocation('user_' + name);
-						var _locSize2 = this.getUniformLocation('user_' + name + 'Size');
-						var _dimLoc2 = this.getUniformLocation('user_' + name + 'Dim');
-
-						gl.uniform3fv(_dimLoc2, _dim2);
-						gl.uniform2fv(_locSize2, _size2);
-						gl.uniform1i(_loc3, this.argumentsLength);
-						break;
+					return retArr;
+				} else if (forNode.init.declarations) {
+					var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));
+					var updateArgument = forNode.update.argument;
+					if (!Array.isArray(declarations) || declarations.length < 1) {
+						console.log(this.jsFunctionString);
+						throw new Error('Error: Incompatible for loop declaration');
 					}
-				default:
-					throw new Error('Input type not supported (WebGL): ' + value);
-			}
-			this.argumentsLength++;
-		}
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getHeaderString
-   *
-   * @desc Get the header string for the program.
-   * This returns an empty string if no sub-kernels are defined.
-   *
-   * @returns {String} result
-   *
-   */
+					if (declarations.length > 1) {
+						var initArgument = null;
+						for (var _i2 = 0; _i2 < declarations.length; _i2++) {
+							var declaration = declarations[_i2];
+							if (declaration.id.name === updateArgument.name) {
+								initArgument = declaration;
+								declarations.splice(_i2, 1);
+							} else {
+								retArr.push('var ');
+								this.astGeneric(declaration, retArr, funcParam);
+								retArr.push(';');
+							}
+						}
 
-	}, {
-		key: '_getHeaderString',
-		value: function _getHeaderString() {
-			return this.subKernels !== null || this.subKernelProperties !== null ?
-			//webgl2 '#version 300 es\n' :
-			'#extension GL_EXT_draw_buffers : require\n' : '';
-		}
+						retArr.push('for (let ');
+						this.astGeneric(initArgument, retArr, funcParam);
+						retArr.push(';');
+					} else {
+						retArr.push('for (');
+						this.astGeneric(forNode.init, retArr, funcParam);
+					}
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getLoopMaxString
-   *
-   * @desc Get the maximum loop size String.
-   *
-   * @returns {String} result
-   *
-   */
+					this.astGeneric(forNode.test, retArr, funcParam);
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr, funcParam);
+					retArr.push(')');
+					this.astGeneric(forNode.body, retArr, funcParam);
+					return retArr;
+				}
+			}
 
-	}, {
-		key: '_getLoopMaxString',
-		value: function _getLoopMaxString() {
-			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + '.0;\n' : ' 1000.0;\n';
+			throw this.astErrorOutput('Invalid for statement', forNode, funcParam);
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getConstantsString
+   * @name astWhileStatement
    *
-   * @desc Generate transpiled glsl Strings for constant parameters sent to a kernel
+   * @desc Parses the abstract syntax tree for *while* loop
    *
-   * They can be defined by *hardcodeConstants*
    *
-   * @returns {String} result
+   * @param {Object} whileNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the parsed openclgl string
    */
 
 	}, {
-		key: '_getConstantsString',
-		value: function _getConstantsString() {
-			var result = [];
-			var threadDim = this.threadDim;
-			var texSize = this.texSize;
-			if (this.hardcodeConstants) {
-				result.push('highp vec3 uOutputDim = vec3(' + threadDim[0] + ',' + threadDim[1] + ', ' + threadDim[2] + ')', 'highp vec2 uTexSize = vec2(' + texSize[0] + ', ' + texSize[1] + ')');
-			} else {
-				result.push('uniform highp vec3 uOutputDim', 'uniform highp vec2 uTexSize');
+		key: 'astWhileStatement',
+		value: function astWhileStatement(whileNode, retArr, funcParam) {
+			if (whileNode.type !== 'WhileStatement') {
+				throw this.astErrorOutput('Invalid while statment', whileNode, funcParam);
 			}
 
-			return this._linesToString(result);
-		}
-
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getTextureCoordinate
-   *
-   * @desc Get texture coordinate string for the program
-   *
-   * @returns {String} result
-   *
-   */
+			retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
+			retArr.push('if (');
+			this.astGeneric(whileNode.test, retArr, funcParam);
+			retArr.push(') {\n');
+			this.astGeneric(whileNode.body, retArr, funcParam);
+			retArr.push('} else {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
 
-	}, {
-		key: '_getTextureCoordinate',
-		value: function _getTextureCoordinate() {
-			var names = this.subKernelOutputVariableNames;
-			if (names === null || names.length < 1) {
-				return 'varying highp vec2 vTexCoord;\n';
-			} else {
-				return 'out highp vec2 vTexCoord;\n';
-			}
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getDecode32EndiannessString
+   * @name astAssignmentExpression
    *
-   * @desc Get Decode32 endianness string for little-endian and big-endian
+   * @desc Parses the abstract syntax tree for *Assignment* Expression
    *
-   * @returns {String} result
+   * @param {Object} assNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getDecode32EndiannessString',
-		value: function _getDecode32EndiannessString() {
-			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		key: 'astAssignmentExpression',
+		value: function astAssignmentExpression(assNode, retArr, funcParam) {
+			this.astGeneric(assNode.left, retArr, funcParam);
+			retArr.push(assNode.operator);
+			this.astGeneric(assNode.right, retArr, funcParam);
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getEncode32EndiannessString
+   * @name astEmptyStatement
    *
-   * @desc Get Encode32 endianness string for little-endian and big-endian
+   * @desc Parses the abstract syntax tree for an *Empty* Statement
    *
-   * @returns {String} result
+   * @param {Object} eNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getEncode32EndiannessString',
-		value: function _getEncode32EndiannessString() {
-			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		key: 'astEmptyStatement',
+		value: function astEmptyStatement(eNode, retArr, funcParam) {
+			//retArr.push(';\n');
+			return retArr;
 		}
 
 		/**
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @memberOf WebGLKernel#
-   * @name _getGetWraparoundString
+   * @name astBlockStatement
    *
-   * @returns {String} wraparound string
-   */
-
-	}, {
-		key: '_getGetWraparoundString',
-		value: function _getGetWraparoundString() {
-			return this.wraparound ? '  xyz = mod(xyz, texDim);\n' : '';
-		}
-
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getGetTextureChannelString
+   * @desc Parses the abstract syntax tree for *Block* statement
+   *
+   * @param {Object} bNode - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getGetTextureChannelString',
-		value: function _getGetTextureChannelString() {
-			if (!this.floatTextures) return '';
-
-			return this._linesToString(['  int channel = int(integerMod(index, 4.0))', '  index = float(int(index) / 4)']);
+		key: 'astBlockStatement',
+		value: function astBlockStatement(bNode, retArr, funcParam) {
+			retArr.push('{\n');
+			for (var i = 0; i < bNode.body.length; i++) {
+				this.astGeneric(bNode.body[i], retArr, funcParam);
+			}
+			retArr.push('}\n');
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getGetTextureIndexString
-   *
-   * @desc Get generic texture index string, if floatTextures flag is true.
+   * @name astExpressionStatement
    *
-   * @example
-   * '  index = float(int(index)/4);\n'
+   * @desc Parses the abstract syntax tree for *generic expression* statement
    *
-   */
-
-	}, {
-		key: '_getGetTextureIndexString',
-		value: function _getGetTextureIndexString() {
-			return this.floatTextures ? '  index = float(int(index)/4);\n' : '';
-		}
-
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name _getGetResultString
+   * @param {Object} esNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getGetResultString',
-		value: function _getGetResultString() {
-			if (!this.floatTextures) return '  return decode32(texel);\n';
-			return this._linesToString(['  if (channel == 0) return texel.r', '  if (channel == 1) return texel.g', '  if (channel == 2) return texel.b', '  if (channel == 3) return texel.a']);
+		key: 'astExpressionStatement',
+		value: function astExpressionStatement(esNode, retArr, funcParam) {
+			this.astGeneric(esNode.expression, retArr, funcParam);
+			retArr.push(';\n');
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getMainParamsString
-   *
-   * @desc Generate transpiled glsl Strings for user-defined parameters sent to a kernel
+   * @name astVariableDeclaration
    *
-   * @param {Array} args - The actual parameters sent to the Kernel
+   * @desc Parses the abstract syntax tree for *Variable Declaration*
    *
-   * @returns {String} result
+   * @param {Object} vardecNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getMainParamsString',
-		value: function _getMainParamsString(args) {
-			var result = [];
-			var paramTypes = this.paramTypes;
-			var paramNames = this.paramNames;
-			for (var i = 0; i < paramNames.length; i++) {
-				var param = args[i];
-				var paramName = paramNames[i];
-				var paramType = paramTypes[i];
-				if (this.hardcodeConstants) {
-					if (paramType === 'Array' || paramType === 'Texture') {
-						var paramDim = utils.getDimensions(param, true);
-						var paramSize = utils.dimToTexSize({
-							floatTextures: this.floatTextures,
-							floatOutput: this.floatOutput
-						}, paramDim);
-
-						result.push('uniform highp sampler2D user_' + paramName, 'highp vec2 user_' + paramName + 'Size = vec2(' + paramSize[0] + '.0, ' + paramSize[1] + '.0)', 'highp vec3 user_' + paramName + 'Dim = vec3(' + paramDim[0] + '.0, ' + paramDim[1] + '.0, ' + paramDim[2] + '.0)');
-					} else if (paramType === 'Number' && Number.isInteger(param)) {
-						result.push('highp float user_' + paramName + ' = ' + param + '.0');
-					} else if (paramType === 'Number') {
-						result.push('highp float user_' + paramName + ' = ' + param);
-					}
-				} else {
-					if (paramType === 'Array' || paramType === 'Texture' || paramType === 'Input') {
-						result.push('uniform highp sampler2D user_' + paramName, 'uniform highp vec2 user_' + paramName + 'Size', 'uniform highp vec3 user_' + paramName + 'Dim');
-					} else if (paramType === 'Number') {
-						result.push('uniform highp float user_' + paramName);
-					}
+		key: 'astVariableDeclaration',
+		value: function astVariableDeclaration(vardecNode, retArr, funcParam) {
+			retArr.push('var ');
+			for (var i = 0; i < vardecNode.declarations.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
 				}
+				this.astGeneric(vardecNode.declarations[i], retArr, funcParam);
 			}
-			return this._linesToString(result);
+			retArr.push(';');
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getMainConstantsString
+   * @name astVariableDeclarator
+   *
+   * @desc Parses the abstract syntax tree for *Variable Declarator*
+   *
+   * @param {Object} ivardecNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getMainConstantsString',
-		value: function _getMainConstantsString() {
-			var result = [];
-			if (this.constants) {
-				for (var name in this.constants) {
-					if (!this.constants.hasOwnProperty(name)) continue;
-					var value = parseFloat(this.constants[name]);
-
-					if (Number.isInteger(value)) {
-						result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
-					} else {
-						result.push('const float constants_' + name + ' = ' + parseFloat(value));
-					}
-				}
+		key: 'astVariableDeclarator',
+		value: function astVariableDeclarator(ivardecNode, retArr, funcParam) {
+			this.astGeneric(ivardecNode.id, retArr, funcParam);
+			if (ivardecNode.init !== null) {
+				retArr.push('=');
+				this.astGeneric(ivardecNode.init, retArr, funcParam);
 			}
-			return this._linesToString(result);
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getKernelString
+   * @name astIfStatement
    *
-   * @desc Get Kernel program string (in *glsl*) for a kernel.
+   * @desc Parses the abstract syntax tree for *If* Statement
    *
-   * @returns {String} result
+   * @param {Object} ifNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getKernelString',
-		value: function _getKernelString() {
-			var result = [];
-			var names = this.subKernelOutputVariableNames;
-			if (names !== null) {
-				result.push('highp float kernelResult = 0.0');
-				for (var i = 0; i < names.length; i++) {
-					result.push('highp float ' + names[i] + ' = 0.0');
-				}
-
-				/* this is v2 prep
-       result.push('highp float kernelResult = 0.0');
-    result.push('layout(location = 0) out highp float fradData0 = 0.0');
-    for (let i = 0; i < names.length; i++) {
-    	result.push(
-           `highp float ${ names[i] } = 0.0`,
-    	  `layout(location = ${ i + 1 }) out highp float fragData${ i + 1 } = 0.0`
-         );
-    }*/
+		key: 'astIfStatement',
+		value: function astIfStatement(ifNode, retArr, funcParam) {
+			retArr.push('if (');
+			this.astGeneric(ifNode.test, retArr, funcParam);
+			retArr.push(')');
+			if (ifNode.consequent.type === 'BlockStatement') {
+				this.astGeneric(ifNode.consequent, retArr, funcParam);
 			} else {
-				result.push('highp float kernelResult = 0.0');
+				retArr.push(' {\n');
+				this.astGeneric(ifNode.consequent, retArr, funcParam);
+				retArr.push('\n}\n');
 			}
 
-			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+			if (ifNode.alternate) {
+				retArr.push('else ');
+				if (ifNode.alternate.type === 'BlockStatement') {
+					this.astGeneric(ifNode.alternate, retArr, funcParam);
+				} else {
+					retArr.push(' {\n');
+					this.astGeneric(ifNode.alternate, retArr, funcParam);
+					retArr.push('\n}\n');
+				}
+			}
+			return retArr;
 		}
 
 		/**
-   *
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getMainResultString
+   * @name astBreakStatement
    *
-   * @desc Get main result string with checks for floatOutput, graphical, subKernelsOutputs, etc.
+   * @desc Parses the abstract syntax tree for *Break* Statement
    *
-   * @returns {String} result
+   * @param {Object} brNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getMainResultString',
-		value: function _getMainResultString() {
-			var names = this.subKernelOutputVariableNames;
-			var result = [];
+		key: 'astBreakStatement',
+		value: function astBreakStatement(brNode, retArr, funcParam) {
+			retArr.push('break;\n');
+			return retArr;
+		}
 
-			if (this.floatOutput) {
-				result.push('  index *= 4.0');
-			}
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astContinueStatement
+   *
+   * @desc Parses the abstract syntax tree for *Continue* Statement
+   *
+   * @param {Object} crNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-			if (this.graphical) {
-				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = actualColor');
-			} else if (this.floatOutput) {
-				var channels = ['r', 'g', 'b', 'a'];
+	}, {
+		key: 'astContinueStatement',
+		value: function astContinueStatement(crNode, retArr, funcParam) {
+			retArr.push('continue;\n');
+			return retArr;
+		}
 
-				for (var i = 0; i < channels.length; ++i) {
-					result.push('  threadId = indexTo3D(index, uOutputDim)');
-					result.push('  kernel()');
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astLogicalExpression
+   *
+   * @desc Parses the abstract syntax tree for *Logical* Expression
+   *
+   * @param {Object} logNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-					if (names) {
-						result.push('  gl_FragData[0].' + channels[i] + ' = kernelResult');
+	}, {
+		key: 'astLogicalExpression',
+		value: function astLogicalExpression(logNode, retArr, funcParam) {
+			retArr.push('(');
+			this.astGeneric(logNode.left, retArr, funcParam);
+			retArr.push(logNode.operator);
+			this.astGeneric(logNode.right, retArr, funcParam);
+			retArr.push(')');
+			return retArr;
+		}
 
-						for (var j = 0; j < names.length; ++j) {
-							result.push('  gl_FragData[' + (j + 1) + '].' + channels[i] + ' = ' + names[j]);
-						}
-					} else {
-						result.push('  gl_FragColor.' + channels[i] + ' = kernelResult');
-					}
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astUpdateExpression
+   *
+   * @desc Parses the abstract syntax tree for *Update* Expression
+   *
+   * @param {Object} uNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-					if (i < channels.length - 1) {
-						result.push('  index += 1.0');
-					}
-				}
-			} else if (names !== null) {
-				result.push('  threadId = indexTo3D(index, uOutputDim)');
-				result.push('  kernel()');
-				result.push('  gl_FragData[0] = encode32(kernelResult)');
-				for (var _i3 = 0; _i3 < names.length; _i3++) {
-					result.push('  gl_FragData[' + (_i3 + 1) + '] = encode32(' + names[_i3] + ')');
-				}
+	}, {
+		key: 'astUpdateExpression',
+		value: function astUpdateExpression(uNode, retArr, funcParam) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr, funcParam);
 			} else {
-				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = encode32(kernelResult)');
+				this.astGeneric(uNode.argument, retArr, funcParam);
+				retArr.push(uNode.operator);
 			}
 
-			return this._linesToString(result);
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _linesToString
+   * @name astUnaryExpression
    *
-   * @param {Array} lines - An Array of strings
+   * @desc Parses the abstract syntax tree for *Unary* Expression
    *
-   * @returns {String} Single combined String, seperated by *\n*
+   * @param {Object} uNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_linesToString',
-		value: function _linesToString(lines) {
-			if (lines.length > 0) {
-				return lines.join(';\n') + ';\n';
+		key: 'astUnaryExpression',
+		value: function astUnaryExpression(uNode, retArr, funcParam) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr, funcParam);
 			} else {
-				return '\n';
+				this.astGeneric(uNode.argument, retArr, funcParam);
+				retArr.push(uNode.operator);
 			}
+
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _replaceArtifacts
+   * @name astThisExpression
    *
-   * @param {String} src - Shader string
-   * @param {Array} map - Variables/Constants associated with shader
+   * @desc Parses the abstract syntax tree for *This* expression
+   *
+   * @param {Object} tNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_replaceArtifacts',
-		value: function _replaceArtifacts(src, map) {
-			return src.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z])*)__;\n/g, function (match, artifact) {
-				if (map.hasOwnProperty(artifact)) {
-					return map[artifact];
-				}
-				throw 'unhandled artifact ' + artifact;
-			});
+		key: 'astThisExpression',
+		value: function astThisExpression(tNode, retArr, funcParam) {
+			retArr.push('_this');
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _addKernels
+   * @name astMemberExpression
    *
-   * @desc Adds all the sub-kernels supplied with this Kernel instance.
+   * @desc Parses the abstract syntax tree for *Member* Expression
+   *
+   * @param {Object} mNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_addKernels',
-		value: function _addKernels() {
-			var builder = this.functionBuilder;
-			var gl = this._webGl;
-
-			builder.addFunctions(this.functions, {
-				constants: this.constants,
-				output: this.output
-			});
-			builder.addNativeFunctions(this.nativeFunctions);
+		key: 'astMemberExpression',
+		value: function astMemberExpression(mNode, retArr, funcParam) {
+			if (mNode.computed) {
+				if (mNode.object.type === 'Identifier') {
+					this.astGeneric(mNode.object, retArr, funcParam);
+					retArr.push('[');
+					this.astGeneric(mNode.property, retArr, funcParam);
+					retArr.push(']');
+				} else {
+					this.astGeneric(mNode.object, retArr, funcParam);
+					var last = retArr.pop();
+					retArr.push('][');
+					this.astGeneric(mNode.property, retArr, funcParam);
+					retArr.push(last);
+				}
+			} else {
+				var unrolled = this.astMemberExpressionUnroll(mNode);
+				if (mNode.property.type === 'Identifier' && mNode.computed) {
+					unrolled = 'user_' + unrolled;
+				}
 
-			builder.addKernel(this.fnString, {
-				prototypeOnly: false,
-				constants: this.constants,
-				output: this.output,
-				debug: this.debug,
-				loopMaxIterations: this.loopMaxIterations
-			}, this.paramNames, this.paramTypes);
+				// Its a reference to `this`, add '_' before
+				if (unrolled.indexOf('this') === 0) {
+					unrolled = '_' + unrolled;
+				}
 
-			if (this.subKernels !== null) {
-				var ext = this.ext = gl.getExtension('WEBGL_draw_buffers');
-				if (!ext) throw new Error('could not instantiate draw buffers extension');
-				this.subKernelOutputTextures = [];
-				this.subKernelOutputVariableNames = [];
-				for (var i = 0; i < this.subKernels.length; i++) {
-					var subKernel = this.subKernels[i];
-					builder.addSubKernel(subKernel, {
-						prototypeOnly: false,
-						constants: this.constants,
-						output: this.output,
-						debug: this.debug,
-						loopMaxIterations: this.loopMaxIterations
-					});
-					this.subKernelOutputTextures.push(this.getSubKernelTexture(i));
-					this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
+				switch (unrolled) {
+					case '_this.output.x':
+						retArr.push(this.output[0]);
+						break;
+					case '_this.output.y':
+						retArr.push(this.output[1]);
+						break;
+					case '_this.output.z':
+						retArr.push(this.output[2]);
+						break;
+					default:
+						retArr.push(unrolled);
 				}
-			} else if (this.subKernelProperties !== null) {
-				var _ext = this.ext = gl.getExtension('WEBGL_draw_buffers');
-				if (!_ext) throw new Error('could not instantiate draw buffers extension');
-				this.subKernelOutputTextures = [];
-				this.subKernelOutputVariableNames = [];
-				var _i4 = 0;
-				for (var p in this.subKernelProperties) {
-					if (!this.subKernelProperties.hasOwnProperty(p)) continue;
-					var _subKernel = this.subKernelProperties[p];
-					builder.addSubKernel(_subKernel, {
-						prototypeOnly: false,
-						constants: this.constants,
-						output: this.output,
-						debug: this.debug,
-						loopMaxIterations: this.loopMaxIterations
-					});
-					this.subKernelOutputTextures.push(this.getSubKernelTexture(p));
-					this.subKernelOutputVariableNames.push(_subKernel.name + 'Result');
-					_i4++;
+			}
+			return retArr;
+		}
+	}, {
+		key: 'astSequenceExpression',
+		value: function astSequenceExpression(sNode, retArr, funcParam) {
+			for (var i = 0; i < sNode.expressions.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
 				}
+				this.astGeneric(sNode.expressions, retArr, funcParam);
 			}
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getFragShaderString
-   *
-   * @desc Get the fragment shader String.
-   * If the String hasn't been compiled yet,
-   * then this method compiles it as well
+   * @name astCallExpression
    *
-   * @param {Array} args - The actual parameters sent to the Kernel
+   * @desc Parses the abstract syntax tree for *call* expression
    *
-   * @returns {String} Fragment Shader string
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns  {Array} the append retArr
    */
 
 	}, {
-		key: '_getFragShaderString',
-		value: function _getFragShaderString(args) {
-			if (this.compiledFragShaderString !== null) {
-				return this.compiledFragShaderString;
+		key: 'astCallExpression',
+		value: function astCallExpression(ast, retArr, funcParam) {
+			if (ast.callee) {
+				// Get the full function call, unrolled
+				var funcName = this.astMemberExpressionUnroll(ast.callee);
+
+				// Register the function into the called registry
+				if (funcParam.calledFunctions.indexOf(funcName) < 0) {
+					funcParam.calledFunctions.push(funcName);
+				}
+				if (!funcParam.hasOwnProperty('funcName')) {
+					funcParam.calledFunctionsArguments[funcName] = [];
+				}
+
+				var functionArguments = [];
+				funcParam.calledFunctionsArguments[funcName].push(functionArguments);
+
+				// Call the function
+				retArr.push(funcName);
+
+				// Open arguments space
+				retArr.push('(');
+
+				// Add the vars
+				for (var i = 0; i < ast.arguments.length; ++i) {
+					var argument = ast.arguments[i];
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					this.astGeneric(argument, retArr, funcParam);
+					if (argument.type === 'Identifier') {
+						var paramIndex = funcParam.paramNames.indexOf(argument.name);
+						if (paramIndex === -1) {
+							functionArguments.push(null);
+						} else {
+							functionArguments.push({
+								name: argument.name,
+								type: funcParam.paramTypes[paramIndex]
+							});
+						}
+					} else {
+						functionArguments.push(null);
+					}
+				}
+
+				// Close arguments space
+				retArr.push(')');
+
+				return retArr;
 			}
-			return this.compiledFragShaderString = this._replaceArtifacts(fragShaderString, this._getFragShaderArtifactMap(args));
+
+			// Failure, unknown expression
+			throw this.astErrorOutput('Unknown CallExpression', ast, funcParam);
+
+			return retArr;
 		}
 
 		/**
-   * @memberOf WebGLKernel#
+   * @memberOf WebGLFunctionNode#
    * @function
-   * @name _getVertShaderString
-   *
-   * @desc Get the vertical shader String
+   * @name astArrayExpression
    *
-   * @param {Array} args - The actual parameters sent to the Kernel
+   * @desc Parses the abstract syntax tree for *Array* Expression
    *
-   * @returns {String} Vertical Shader string
+   * @param {Object} arrNode - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {Array} the append retArr
    */
 
 	}, {
-		key: '_getVertShaderString',
-		value: function _getVertShaderString(args) {
-			if (this.compiledVertShaderString !== null) {
-				return this.compiledVertShaderString;
+		key: 'astArrayExpression',
+		value: function astArrayExpression(arrNode, retArr, funcParam) {
+			var arrLen = arrNode.elements.length;
+
+			retArr.push('new Float32Array(');
+			for (var i = 0; i < arrLen; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+				var subNode = arrNode.elements[i];
+				this.astGeneric(subNode, retArr, funcParam);
 			}
-			//TODO: webgl2 compile like frag shader
-			return this.compiledVertShaderString = vertShaderString;
+			retArr.push(')');
+
+			return retArr;
+
+			// // Failure, unknown expression
+			// throw this.astErrorOutput(
+			// 	'Unknown  ArrayExpression',
+			// 	arrNode, funcParam
+			//);
+		}
+	}, {
+		key: 'astDebuggerStatement',
+		value: function astDebuggerStatement(arrNode, retArr, funcParam) {
+			retArr.push('debugger;');
+			return retArr;
 		}
+	}], [{
+		key: 'astFunctionPrototype',
+		value: function astFunctionPrototype(ast, retArr, funcParam) {
+			// Setup function return type and name
+			if (funcParam.isRootKernel || funcParam.isSubKernel) {
+				return retArr;
+			}
 
-		/**
-   * @memberOf WebGLKernel#
-   * @function
-   * @name toString
-   *
-   * @desc Returns the *pre-compiled* Kernel as a JS Object String, that can be reused.
-   *
-   */
+			retArr.push(funcParam.returnType);
+			retArr.push(' ');
+			retArr.push(funcParam.functionName);
+			retArr.push('(');
+
+			// Arguments handling
+			for (var i = 0; i < funcParam.paramNames.length; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+
+				retArr.push(funcParam.paramTypes[i]);
+				retArr.push(' ');
+				retArr.push('user_');
+				retArr.push(funcParam.paramNames[i]);
+			}
 
-	}, {
-		key: 'toString',
-		value: function toString() {
-			return kernelString(this);
-		}
-	}, {
-		key: 'addFunction',
-		value: function addFunction(fn) {
-			this.functionBuilder.addFunction(null, fn);
+			retArr.push(');\n');
+
+			return retArr;
 		}
 	}]);
 
-	return WebGLKernel;
-}(KernelBase);
-},{"../../core/texture":72,"../../core/utils":74,"../kernel-base":57,"./kernel-string":62,"./shader-frag":65,"./shader-vert":66}],64:[function(require,module,exports){
+	return CPUFunctionNode;
+}(BaseFunctionNode);
+},{"../../core/utils":75,"../function-node-base":57}],53:[function(require,module,exports){
+'use strict';
+
+var utils = require('../../core/utils');
+var kernelRunShortcut = require('../kernel-run-shortcut');
+
+module.exports = function (cpuKernel, name) {
+  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: function ' + utils.allPropertiesOf.toString() + ',\n      clone: function ' + utils.clone.toString() + ',\n      /*splitArray: function ' + utils.splitArray.toString() + ',\n      getArgumentType: function ' + utils.getArgumentType.toString() + ',\n      getOutput: function ' + utils.getOutput.toString() + ',\n      dimToTexSize: function ' + utils.dimToTexSize.toString() + ',\n      copyFlatten: function ' + utils.copyFlatten.toString() + ',\n      flatten: function ' + utils.flatten.toString() + ',\n      systemEndianness: \'' + utils.systemEndianness() + '\',\n      initWebGl: function ' + utils.initWebGl.toString() + ',\n      isArray: function ' + utils.isArray.toString() + '*/\n    };\n    class ' + (name || 'Kernel') + ' {\n      constructor() {        \n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = ' + JSON.stringify(cpuKernel.paramNames) + ';\n        this.paramTypes = ' + JSON.stringify(cpuKernel.paramTypes) + ';\n        this.texSize = ' + JSON.stringify(cpuKernel.texSize) + ';\n        this.output = ' + JSON.stringify(cpuKernel.output) + ';\n        this._kernelString = `' + cpuKernel._kernelString + '`;\n        this.output = ' + JSON.stringify(cpuKernel.output) + ';\n\t\t    this.run = function() {\n          this.run = null;\n          this.build();\n          return this.run.apply(this, arguments);\n        }.bind(this);\n        this.thread = {\n          x: 0,\n          y: 0,\n          z: 0\n        };\n      }\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      ' + cpuKernel.build.toString() + '\n      run () { ' + cpuKernel.kernelString + ' }\n      getKernelString() { return this._kernelString; }\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
+};
+},{"../../core/utils":75,"../kernel-run-shortcut":59}],54:[function(require,module,exports){
 'use strict';
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -12522,226 +12030,337 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-var RunnerBase = require('../runner-base');
-var WebGLKernel = require('./kernel');
+var KernelBase = require('../kernel-base');
 var utils = require('../../core/utils');
-var WebGLFunctionBuilder = require('./function-builder');
+var kernelString = require('./kernel-string');
 
-module.exports = function (_RunnerBase) {
-	_inherits(WebGLRunner, _RunnerBase);
+module.exports = function (_KernelBase) {
+	_inherits(CPUKernel, _KernelBase);
 
 	/**
-  * @constructor WebGLRunner
+  * @constructor CPUKernel
   *
- 	 * @extends RunnerBase
-  	 * @desc Instantiates a Runner instance for the kernel.
+  * @desc Kernel Implementation for CPU.
   * 
-  * @param {Object} settings - Settings to instantiate properties in RunnerBase, with given values
+  * <p>Instantiates properties to the CPU Kernel.</p>
+  *
+  * @extends KernelBase
+  *
+  * @prop {Object} thread - The thread dimensions, x, y and z
+  * @prop {Object} output - The canvas dimensions
+  * @prop {Object} functionBuilder - Function Builder instance bound to this Kernel
+  * @prop {Function} run - Method to run the kernel
   *
   */
-	function WebGLRunner(settings) {
-		_classCallCheck(this, WebGLRunner);
+	function CPUKernel(fnString, settings) {
+		_classCallCheck(this, CPUKernel);
 
-		var _this = _possibleConstructorReturn(this, (WebGLRunner.__proto__ || Object.getPrototypeOf(WebGLRunner)).call(this, new WebGLFunctionBuilder(), settings));
+		var _this = _possibleConstructorReturn(this, (CPUKernel.__proto__ || Object.getPrototypeOf(CPUKernel)).call(this, fnString, settings));
 
-		_this.Kernel = WebGLKernel;
-		_this.kernel = null;
+		_this._fnBody = utils.getFunctionBodyFromString(fnString);
+		_this._fn = null;
+		_this.run = null;
+		_this._canvasCtx = null;
+		_this._imageData = null;
+		_this._colorData = null;
+		_this._kernelString = null;
+		_this.thread = {
+			x: 0,
+			y: 0,
+			z: 0
+		};
+
+		_this.run = function () {
+			this.run = null;
+			this.build.apply(this, arguments);
+			return this.run.apply(this, arguments);
+		}.bind(_this);
 		return _this;
 	}
 
 	/**
-  * @memberOf WebGLRunner#
+  * @memberOf CPUKernel#
   * @function
-  * @name getMode
+  * @name validateOptions
   *
-  * @desc Return the current mode in which gpu.js is executing.
-  * 
-  * @returns {String} The current mode; "cpu".
+  * @desc Validate options related to CPU Kernel, such as 
+  * dimensions size, and auto dimension support.
   *
   */
 
 
-	_createClass(WebGLRunner, [{
-		key: 'getMode',
-		value: function getMode() {
-			return 'gpu';
+	_createClass(CPUKernel, [{
+		key: 'validateOptions',
+		value: function validateOptions() {
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw 'Auto dimensions only supported for kernels with only one input';
+				}
+
+				var argType = utils.getArgumentType(arguments[0]);
+				if (argType === 'Array') {
+					this.output = utils.getDimensions(argType);
+				} else if (argType === 'Texture') {
+					this.output = arguments[0].output;
+				} else {
+					throw 'Auto dimensions not supported for input type: ' + argType;
+				}
+			}
 		}
-	}]);
 
-	return WebGLRunner;
-}(RunnerBase);
-},{"../../core/utils":74,"../runner-base":59,"./function-builder":60,"./kernel":63}],65:[function(require,module,exports){
-"use strict";
+		/**
+   * @memberOf CPUKernel#
+   * @function
+   * @name build
+   *
+   * @desc Builds the Kernel, by generating the kernel 
+   * string using thread dimensions, and arguments 
+   * supplied to the kernel.
+   *
+   * <p>If the graphical flag is enabled, canvas is used.</p>
+   *
+   */
 
-module.exports = "__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n#define EPSILON 0.0000001;\n\n__CONSTANTS__;\n\nvarying highp vec2 vTexCoord;\n\nvec4 round(vec4 x) {\n  return floor(x + 0.5);\n}\n\nhighp float round(highp float x) {\n  return floor(x + 0.5);\n}\n\nvec2 integerMod(vec2 x, float y) {\n  vec2 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec3 integerMod(vec3 x, float y) {\n  vec3 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec4 integerMod(vec4 x, vec4 y) {\n  vec4 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nhighp float integerMod(highp float x, highp float y) {\n  highp float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nhighp int integerMod(highp int x, highp int y) {\n  return int(integerMod(float(x), float(y)));\n}\n\n// Here be dragons!\n// DO NOT OPTIMIZE THIS CODE\n// YOU WILL BREAK SOMETHING ON SOMEBODY'S MACHINE\n// LEAVE IT AS IT IS, LEST YOU WASTE YOUR OWN TIME\nconst vec2 MAGIC_VEC = vec2(1.0, -256.0);\nconst vec4 SCALE_FACTOR = vec4(1.0, 256.0, 65536.0, 0.0);\nconst vec4 SCALE_FACTOR_INV = vec4(1.0, 0.00390625, 0.0000152587890625, 0.0); // 1, 1/256, 1/65536\nhighp float decode32(highp vec4 rgba) {\n  __DECODE32_ENDIANNESS__;\n  rgba *= 255.0;\n  vec2 gte128;\n  gte128.x = rgba.b >= 128.0 ? 1.0 : 0.0;\n  gte128.y = rgba.a >= 128.0 ? 1.0 : 0.0;\n  float exponent = 2.0 * rgba.a - 127.0 + dot(gte128, MAGIC_VEC);\n  float res = exp2(round(exponent));\n  rgba.b = rgba.b - 128.0 * gte128.x;\n  res = dot(rgba, SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;\n  res *= gte128.y * -2.0 + 1.0;\n  return res;\n}\n\nhighp vec4 encode32(highp float f) {\n  highp float F = abs(f);\n  highp float sign = f < 0.0 ? 1.0 : 0.0;\n  highp float exponent = floor(log2(F));\n  highp float mantissa = (exp2(-exponent) * F);\n  // exponent += floor(log2(mantissa));\n  vec4 rgba = vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;\n  rgba.rg = integerMod(rgba.rg, 256.0);\n  rgba.b = integerMod(rgba.b, 128.0);\n  rgba.a = exponent*0.5 + 63.5;\n  rgba.ba += vec2(integerMod(exponent+127.0, 2.0), sign) * 128.0;\n  rgba = floor(rgba);\n  rgba *= 0.003921569; // 1/255\n  __ENCODE32_ENDIANNESS__;\n  return rgba;\n}\n// Dragons end here\n\nhighp float index;\nhighp vec3 threadId;\n\nhighp vec3 indexTo3D(highp float idx, highp vec3 texDim) {\n  highp float z = floor(idx / (texDim.x * texDim.y));\n  idx -= z * texDim.x * texDim.y;\n  highp float y = floor(idx / texDim.x);\n  highp float x = integerMod(idx, texDim.x);\n  return vec3(x, y, z);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float z, highp float y, highp float x) {\n  highp vec3 xyz = vec3(x, y, z);\n  xyz = floor(xyz + 0.5);\n  __GET_WRAPAROUND__;\n  highp float index = round(xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z));\n  __GET_TEXTURE_CHANNEL__;\n  highp float w = round(texSize.x);\n  vec2 st = vec2(integerMod(index, w), float(int(index) / int(w))) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  highp vec4 texel = texture2D(tex, st / texSize);\n  __GET_RESULT__;\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float y, highp float x) {\n  return get(tex, texSize, texDim, 0.0, y, x);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float x) {\n  return get(tex, texSize, texDim, 0.0, 0.0, x);\n}\n\nhighp vec4 actualColor;\nvoid color(float r, float g, float b, float a) {\n  actualColor = vec4(r,g,b,a);\n}\n\nvoid color(float r, float g, float b) {\n  color(r,g,b,1.0);\n}\n\n__MAIN_PARAMS__;\n__MAIN_CONSTANTS__;\n__KERNEL__;\n\nvoid main(void) {\n  index = floor(vTexCoord.s * float(uTexSize.x)) + floor(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
-},{}],66:[function(require,module,exports){
-"use strict";
+	}, {
+		key: 'build',
+		value: function build() {
+			this.setupParams(arguments);
+			var threadDim = this.threadDim = utils.clone(this.output);
 
-module.exports = "precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nattribute highp vec2 aPos;\nattribute highp vec2 aTexCoord;\n\nvarying highp vec2 vTexCoord;\nuniform vec2 ratio;\n\nvoid main(void) {\n  gl_Position = vec4((aPos + vec2(1)) * ratio + vec2(-1), 0, 1);\n  vTexCoord = aTexCoord;\n}";
-},{}],67:[function(require,module,exports){
-'use strict';
+			while (threadDim.length < 3) {
+				threadDim.push(1);
+			}
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+			if (this.graphical) {
+				var canvas = this.getCanvas();
+				canvas.width = threadDim[0];
+				canvas.height = threadDim[1];
+				this._canvasCtx = canvas.getContext('2d');
+				this._imageData = this._canvasCtx.createImageData(threadDim[0], threadDim[1]);
+				this._colorData = new Uint8ClampedArray(threadDim[0] * threadDim[1] * 4);
+			}
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+			var kernelString = this.getKernelString();
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+			if (this.debug) {
+				console.log('Options:');
+				console.dir(this);
+				console.log('Function output:');
+				console.log(kernelString);
+			}
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+			this.kernelString = kernelString;
+			this.run = new Function([], kernelString).bind(this)();
+		}
+	}, {
+		key: 'color',
+		value: function color(r, g, b, a) {
+			if (typeof a === 'undefined') {
+				a = 1;
+			}
 
-var WebGLKernel = require('./kernel');
-var utils = require('../../core/utils');
+			r = Math.floor(r * 255);
+			g = Math.floor(g * 255);
+			b = Math.floor(b * 255);
+			a = Math.floor(a * 255);
 
-/**
- * @class WebGLValidatorKernel
- *
- * @desc Helper class for WebGLKernel to validate texture size and dimensions.
- *
- */
-module.exports = function (_WebGLKernel) {
-	_inherits(WebGLValidatorKernel, _WebGLKernel);
+			var width = this.output[0];
+			var height = this.output[1];
 
-	function WebGLValidatorKernel() {
-		_classCallCheck(this, WebGLValidatorKernel);
+			var x = this.thread.x;
+			var y = height - this.thread.y - 1;
 
-		return _possibleConstructorReturn(this, (WebGLValidatorKernel.__proto__ || Object.getPrototypeOf(WebGLValidatorKernel)).apply(this, arguments));
-	}
+			var index = x + y * width;
 
-	_createClass(WebGLValidatorKernel, [{
-		key: 'validateOptions',
+			this._colorData[index * 4 + 0] = r;
+			this._colorData[index * 4 + 1] = g;
+			this._colorData[index * 4 + 2] = b;
+			this._colorData[index * 4 + 3] = a;
+		}
+
+		/**
+   * @memberOf CPUKernel#
+   * @function
+   * @name getKernelString
+   *
+   * @desc Generates kernel string for this kernel program.
+   * 
+   * <p>If sub-kernels are supplied, they are also factored in.
+   * This string can be saved by calling the `toString` method
+   * and then can be reused later.</p>
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: 'getKernelString',
+		value: function getKernelString() {
+			var _this2 = this;
+
+			if (this._kernelString !== null) return this._kernelString;
+
+			var builder = this.functionBuilder;
+
+			// Thread dim fix (to make compilable)
+			var threadDim = this.threadDim || (this.threadDim = utils.clone(this.output));
+			while (threadDim.length < 3) {
+				threadDim.push(1);
+			}
+
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations
+			}, this.paramNames, this.paramTypes);
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+
+			if (this.subKernels !== null) {
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				for (var i = 0; i < this.subKernels.length; i++) {
+					var subKernel = this.subKernels[i];
+					builder.addSubKernel(subKernel, {
+						prototypeOnly: false,
+						constants: this.constants,
+						output: this.output,
+						debug: this.debug,
+						loopMaxIterations: this.loopMaxIterations
+					});
+					this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
+				}
+			} else if (this.subKernelProperties !== null) {
+				this.subKernelOutputVariableNames = [];
+				var _i = 0;
+				for (var p in this.subKernelProperties) {
+					if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+					var _subKernel = this.subKernelProperties[p];
+					builder.addSubKernel(_subKernel);
+					this.subKernelOutputVariableNames.push(_subKernel.name + 'Result');
+					_i++;
+				}
+			}
 
+			var prototypes = builder.getPrototypes();
+			var kernel = prototypes.shift();
+			var kernelString = this._kernelString = '\n\t\tvar LOOP_MAX = ' + this._getLoopMaxString() + ';\n\t\tvar _this = this;\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '  var ' + name + ' = null;\n';
+			}).join('')) + '\n    return function (' + this.paramNames.map(function (paramName) {
+				return 'user_' + paramName;
+			}).join(', ') + ') {\n    var ret = new Array(' + threadDim[2] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '  ' + name + 'Z = new Array(' + threadDim[2] + ');\n';
+			}).join('')) + '\n    for (this.thread.z = 0; this.thread.z < ' + threadDim[2] + '; this.thread.z++) {\n      ret[this.thread.z] = new Array(' + threadDim[1] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '    ' + name + 'Z[this.thread.z] = new Array(' + threadDim[1] + ');\n';
+			}).join('')) + '\n      for (this.thread.y = 0; this.thread.y < ' + threadDim[1] + '; this.thread.y++) {\n        ret[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n  ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '      ' + name + 'Z[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n';
+			}).join('')) + '\n        for (this.thread.x = 0; this.thread.x < ' + threadDim[0] + '; this.thread.x++) {\n          var kernelResult;\n          ' + kernel + '\n          ret[this.thread.z][this.thread.y][this.thread.x] = kernelResult;\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '        ' + name + 'Z[this.thread.z][this.thread.y][this.thread.x] = ' + name + ';\n';
+			}).join('')) + '\n          }\n        }\n      }\n      \n      if (this.graphical) {\n        this._imageData.data.set(this._colorData);\n        this._canvasCtx.putImageData(this._imageData, 0, 0);\n        return;\n      }\n      \n      if (this.output.length === 1) {\n        ret = ret[0][0];\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '    ' + name + ' = ' + name + 'Z[0][0];\n';
+			}).join('')) + '\n      \n    } else if (this.output.length === 2) {\n      ret = ret[0];\n      ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {
+				return '    ' + name + ' = ' + name + 'Z[0];\n';
+			}).join('')) + '\n    }\n    \n    ' + (this.subKernelOutputVariableNames === null ? 'return ret;\n' : this.subKernels !== null ? 'var result = [\n        ' + this.subKernelOutputVariableNames.map(function (name) {
+				return '' + name;
+			}).join(',\n') + '\n      ];\n      result.result = ret;\n      return result;\n' : 'return {\n        result: ret,\n        ' + Object.keys(this.subKernelProperties).map(function (name, i) {
+				return name + ': ' + _this2.subKernelOutputVariableNames[i];
+			}).join(',\n') + '\n      };') + '\n    ' + (prototypes.length > 0 ? prototypes.join('\n') : '') + '\n    }.bind(this);';
+			return kernelString;
+		}
 
-		/** 
-   * @memberOf WebGLValidatorKernel#
+		/**
+   * @memberOf CPUKernel#
    * @function
-   * @name validateOptions
+   * @name toString
+   *
+   * @desc Returns the *pre-compiled* Kernel as a JS Object String, that can be reused.
    *
    */
-		value: function validateOptions() {
-			this.texSize = utils.dimToTexSize({
-				floatTextures: this.floatTextures,
-				floatOutput: this.floatOutput
-			}, this.output, true);
-		}
-	}]);
-
-	return WebGLValidatorKernel;
-}(WebGLKernel);
-},{"../../core/utils":74,"./kernel":63}],68:[function(require,module,exports){
-'use strict';
-
-var utils = require('./utils');
-module.exports = function alias(name, fn) {
-	var fnString = fn.toString();
-	return new Function('return function ' + name + ' (' + utils.getParamNamesFromString(fnString).join(', ') + ') {' + utils.getFunctionBodyFromString(fnString) + '}')();
-};
-},{"./utils":74}],69:[function(require,module,exports){
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var UtilsCore = require("./utils-core");
-
-/**
- * This is a minimalistic version of GPU.js used 
- * to run precompiled GPU.JS code.
- *
- * This intentionally excludes the JS AST compiller : which is 400kb alone/
- *
- * @class GPUCore
- */
-module.exports = function () {
-	function GPUCore() {
-		_classCallCheck(this, GPUCore);
-	}
-
-	_createClass(GPUCore, null, [{
-		key: "validateKernelObj",
 
+	}, {
+		key: 'toString',
+		value: function toString() {
+			return kernelString(this);
+		}
 
 		/**
-   * @name validateKernelObj
+   * @memberOf CPUKernel#
    * @function
-   * @static
-   * @memberOf GPUCore
-   *
-   * @description Validates the KernelObj to comply with the defined format
-   * Note that this does only a limited sanity check, and does not  
-   * guarantee a full working validation.
-   *
-   * For the kernel object format see : <kernelObj-format>
+   * @name precompileKernelObj
    *
-   * @param {Object|String} kernelObj - KernelObj used to validate
+   * @desc Precompile the kernel into a single object, 
+   * that can be used for building the execution kernel subsequently.
    *
-   * @returns {Object} The validated kernel object, converted from JSON if needed
+   * @param {Array} argTypes - Array of argument types
+   *     
+   * Return:
+   *     Compiled kernel {Object}
    *
    */
-		value: function validateKernelObj(kernelObj) {
-
-			// NULL validation
-			if (kernelObj === null) {
-				throw "KernelObj being validated is NULL";
-			}
-
-			// String JSON conversion
-			if (typeof kernelObj === "string") {
-				try {
-					kernelObj = JSON.parse(kernelObj);
-				} catch (e) {
-					console.error(e);
-					throw "Failed to convert KernelObj from JSON string";
-				}
 
-				// NULL validation
-				if (kernelObj === null) {
-					throw "Invalid (NULL) KernelObj JSON string representation";
-				}
-			}
+	}, {
+		key: 'precompileKernelObj',
+		value: function precompileKernelObj(argTypes) {
 
-			// Check for kernel obj flag
-			if (kernelObj.isKernelObj !== true) {
-				throw "Failed missing isKernelObj flag check";
-			}
+			var threadDim = this.threadDim || (this.threadDim = utils.clone(this.output));
 
-			// Return the validated kernelObj
-			return kernelObj;
+			return {
+				threadDim: threadDim
+			};
 		}
 
 		/**
-   * @name loadKernelObj
+   * @memberOf CPUKernel
    * @function
+   * @name compileKernel
    * @static
-   * @memberOf GPUCore
    *
-   * @description Loads the precompiled kernel object. For GPUCore this is the ONLY way to create the kernel.
-   * To generate the kernelObj use <Kernel.exportKernelObj>
+   * @desc Takes a previously precompiled kernel object,
+   * and complete compilation into a full kernel
+   * 
+   * @returns {Function} Compiled kernel
    *
-   * Note that this function calls <validateKernelObj> internally, and throws an exception if it fails.
+   */
+
+	}, {
+		key: '_getLoopMaxString',
+
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getLoopMaxString
    *
-   * @see GPUCore.validateKernelObj
-   * @see	Kernel.exportKernelObj
+   * @desc Get the maximum loop size String.
    *
-   * @param {Object} kernelObj - The precompiled kernel object
-   * @param {Object} inOpt - [Optional] the option overrides to use
+   * @returns {String} result
    *
-   * @returns {Function} The kernel function
-   * 
    */
+		value: function _getLoopMaxString() {
+			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + ';\n' : ' 1000;\n';
+		}
+	}], [{
+		key: 'compileKernel',
+		value: function compileKernel(precompileObj) {
 
-	}, {
-		key: "loadKernelObj",
-		value: function loadKernelObj(kernelObj, inOpt) {
+			// Extract values from precompiled obj
+			var threadDim = precompileObj.threadDim;
 
-			// Validates the kernelObj, throws an exception if it fails
-			kernelObj = validateKernelObj(kernelObj);
+			// Normalize certain values : For actual build
+			while (threadDim.length < 3) {
+				threadDim.push(1);
+			}
 		}
 	}]);
 
-	return GPUCore;
-}();
-},{"./utils-core":73}],70:[function(require,module,exports){
+	return CPUKernel;
+}(KernelBase);
+},{"../../core/utils":75,"../kernel-base":58,"./kernel-string":53}],55:[function(require,module,exports){
 'use strict';
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -12752,5190 +12371,5671 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-var utils = require('./utils');
-var WebGLRunner = require('../backend/web-gl/runner');
-var CPURunner = require('../backend/cpu/runner');
-var WebGLValidatorKernel = require('../backend/web-gl/validator-kernel');
-var GPUCore = require("./gpu-core");
-
-/**
- * Initialises the GPU.js library class which manages the webGlContext for the created functions.
- * @class
- * @extends GPUCore
- */
+var utils = require('../../core/utils');
+var RunnerBase = require('../runner-base');
+var CPUKernel = require('./kernel');
+var CPUFunctionBuilder = require('./function-builder');
 
-var GPU = function (_GPUCore) {
-	_inherits(GPU, _GPUCore);
+module.exports = function (_RunnerBase) {
+	_inherits(CPURunner, _RunnerBase);
 
 	/**
-  * Creates an instance of GPU.
-  * @param {any} settings - Settings to set mode, andother properties. See #GPUCore
-  * @memberOf GPU#
-  */
-	function GPU(settings) {
-		_classCallCheck(this, GPU);
-
-		var _this = _possibleConstructorReturn(this, (GPU.__proto__ || Object.getPrototypeOf(GPU)).call(this, settings));
-
-		settings = settings || {};
-		_this._canvas = settings.canvas || null;
-		_this._webGl = settings.webGl || null;
-		var mode = settings.mode;
-		var detectedMode = void 0;
-		if (!utils.isWebGlSupported()) {
-			if (mode && mode !== 'cpu') {
-				throw new Error('A requested mode of "' + mode + '" and is not supported');
-			} else {
-				console.warn('Warning: gpu not supported, falling back to cpu support');
-				detectedMode = 'cpu';
-			}
-		} else {
-			detectedMode = mode || 'gpu';
-		}
-
-		_this.kernels = [];
-
-		var runnerSettings = {
-			canvas: _this._canvas,
-			webGl: _this._webGl
-		};
-
-		switch (detectedMode) {
-			case 'cpu':
-				_this._runner = new CPURunner(runnerSettings);
-				break;
-			case 'webgl': // for testing
-			case 'gpu':
-				_this._runner = new WebGLRunner(runnerSettings);
-				break;
-			case 'webgl-validator':
-				// for internal
-				_this._runner = new WebGLRunner(runnerSettings);
-				_this._runner.Kernel = WebGLValidatorKernel;
-				break;
-			default:
-				throw new Error('"' + mode + '" mode is not defined');
-		}
+  * @constructor CPURunner
+  *
+  * @desc Instantiates a Runner instance for the kernel.
+  * 
+  * @extends RunnerBase
+  *
+  * @param {Object} settings - Settings to instantiate properties in RunnerBase, with given values
+  *
+  */
+
+	function CPURunner(settings) {
+		_classCallCheck(this, CPURunner);
+
+		var _this = _possibleConstructorReturn(this, (CPURunner.__proto__ || Object.getPrototypeOf(CPURunner)).call(this, new CPUFunctionBuilder(), settings));
+
+		_this.Kernel = CPUKernel;
+		_this.kernel = null;
 		return _this;
 	}
+
 	/**
-  *
-  * This creates a callable function object to call the kernel function with the argument parameter set
-  *
-  * @name createKernel
+  * @memberOf CPURunner#
   * @function
-  * @memberOf GPU##
-  *
-  * @param {Function} fn - The calling to perform the conversion
-  * @param {Object} settings - The parameter configuration object
-  * @property {String} settings.dimensions - Thread dimension array (Defeaults to [1024])
-  * @property {String} settings.mode - CPU / GPU configuration mode (Defaults to null)
-  *
-  * The following modes are supported
-  * *'falsey'* : Attempts to build GPU mode, else fallbacks
-  * *'gpu'* : Attempts to build GPU mode, else fallbacks
-  * *'cpu'* : Forces JS fallback mode only
-  *
+  * @name getMode()
   *
-  * @returns {Function} callable function to run
+  * Return the current mode in which gpu.js is executing.
+  * 
+  * @returns {String} The current mode; "cpu".
   *
   */
 
 
-	_createClass(GPU, [{
-		key: 'createKernel',
-		value: function createKernel(fn, settings) {
-			//
-			// basic parameters safety checks
-			//
-			if (typeof fn === 'undefined') {
-				throw 'Missing fn parameter';
-			}
-			if (!utils.isFunction(fn) && typeof fn !== 'string') {
-				throw 'fn parameter not a function';
-			}
+	_createClass(CPURunner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'cpu';
+		}
+	}]);
 
-			var kernel = this._runner.buildKernel(fn, settings || {});
+	return CPURunner;
+}(RunnerBase);
+},{"../../core/utils":75,"../runner-base":60,"./function-builder":51,"./kernel":54}],56:[function(require,module,exports){
+'use strict';
 
-			//if canvas didn't come from this, propagate from kernel
-			if (!this._canvas) {
-				this._canvas = kernel.getCanvas();
-			}
-			if (!this._runner.canvas) {
-				this._runner.canvas = kernel.getCanvas();
-			}
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-			this.kernels.push(kernel);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-			return kernel;
+module.exports = function () {
+
+	/**
+  * @constructor FunctionBuilderBase
+  *
+  * @desc This handles all the raw state, converted state, etc. of a single function.
+  * [INTERNAL] A collection of functionNodes.
+  * 
+  * @prop {Object} nodeMap - Object map, where nodeMap[function] = new FunctionNode;
+  * @prop {Object} gpu - The current gpu instance bound to this builder
+  * @prop {Object} rootKernel - The root kernel object, contains the paramNames, dimensions etc.
+  * 
+  */
+	function FunctionBuilderBase(gpu) {
+		_classCallCheck(this, FunctionBuilderBase);
+
+		this.nodeMap = {};
+		this.nativeFunctions = {};
+		this.gpu = gpu;
+		this.rootKernel = null;
+		this.Node = null;
+	}
+
+	_createClass(FunctionBuilderBase, [{
+		key: 'addNativeFunction',
+		value: function addNativeFunction(functionName, glslFunctionString) {
+			this.nativeFunctions[functionName] = glslFunctionString;
 		}
 
 		/**
-   *
-   * Create a super kernel which executes sub kernels
-   * and saves their output to be used with the next sub kernel.
-   * This can be useful if we want to save the output on one kernel,
-   * and then use it as an input to another kernel. *Machine Learning*
-   *
-   * @name createKernelMap
+   * @memberOf FunctionBuilderBase#
    * @function
-   * @memberOf GPU#
-   *
-   * @param {Object|Array} subKernels - Sub kernels for this kernel
-   * @param {Function} rootKernel - Root kernel
-   *
-   * @returns {Function} callable kernel function
-   *
-   * @example
-   * const megaKernel = gpu.createKernelMap({
-   *   addResult: function add(a, b) {
-   *     return a[this.thread.x] + b[this.thread.x];
-   *   },
-   *   multiplyResult: function multiply(a, b) {
-   *     return a[this.thread.x] * b[this.thread.x];
-   *   },
-   *  }, function(a, b, c) {
-   *       return multiply(add(a, b), c);
-   * });
+   * @name addFunction
    *
-   * megaKernel(a, b, c);
+   * @desc Instantiates a FunctionNode, and add it to the nodeMap
    *
-   * Note: You can also define subKernels as an array of functions.
-   * > [add, multiply]
+   * @param {String} functionName - Function name to assume, if its null, it attempts to extract from the function
+   * @param {Function} jsFunction - JS Function to do conversion
+   * @param {Object} [options]
+   * @param {String[]|Object} [paramTypes] - Parameter type array, assumes all parameters are 'float' if falsey
+   * @param {String} [returnType] - The return type, assumes 'float' if falsey
    *
    */
 
 	}, {
-		key: 'createKernelMap',
-		value: function createKernelMap() {
-			var fn = void 0;
-			var settings = void 0;
-			if (typeof arguments[arguments.length - 2] === 'function') {
-				fn = arguments[arguments.length - 2];
-				settings = arguments[arguments.length - 1];
-			} else {
-				fn = arguments[arguments.length - 1];
-			}
-
-			if (!utils.isWebGlDrawBuffersSupported()) {
-				this._runner = new CPURunner(settings);
-			}
-
-			var kernel = this.createKernel(fn, settings);
-			if (Array.isArray(arguments[0])) {
-				var functions = arguments[0];
-				for (var i = 0; i < functions.length; i++) {
-					kernel.addSubKernel(functions[i]);
-				}
-			} else {
-				var _functions = arguments[0];
-				for (var p in _functions) {
-					if (!_functions.hasOwnProperty(p)) continue;
-					kernel.addSubKernelProperty(p, _functions[p]);
+		key: 'addFunction',
+		value: function addFunction(functionName, jsFunction, options, paramTypes, returnType) {
+			this.addFunctionNode(new this.Node(functionName, jsFunction, options, paramTypes, returnType).setAddFunction(this.addFunction.bind(this)));
+		}
+	}, {
+		key: 'addFunctions',
+		value: function addFunctions(functions, options) {
+			if (functions) {
+				if (Array.isArray(functions)) {
+					for (var i = 0; i < functions.length; i++) {
+						this.addFunction(null, functions[i], options);
+					}
+				} else {
+					for (var p in functions) {
+						this.addFunction(p, functions[p], options);
+					}
 				}
 			}
-
-			return kernel;
+		}
+	}, {
+		key: 'addNativeFunctions',
+		value: function addNativeFunctions(nativeFunctions) {
+			for (var functionName in nativeFunctions) {
+				if (!nativeFunctions.hasOwnProperty(functionName)) continue;
+				this.addNativeFunction(functionName, nativeFunctions[functionName]);
+			}
 		}
 
 		/**
+   * @memberOf FunctionBuilderBase#
+   * @function
+   * @name addFunctionNode
    *
-   * Combine different kernels into one super Kernel,
-   * useful to perform multiple operations inside one
-   * kernel without the penalty of data transfer between
-   * cpu and gpu.
+   * @desc Add the function node directly
    *
-   * The number of kernel functions sent to this method can be variable.
-   * You can send in one, two, etc.
+   * @param {functionNode} inNode - functionNode to add
    *
-   * @name combineKernels
+   */
+
+	}, {
+		key: 'addFunctionNode',
+		value: function addFunctionNode(inNode) {
+			this.nodeMap[inNode.functionName] = inNode;
+			if (inNode.isRootKernel) {
+				this.rootKernel = inNode;
+			}
+		}
+
+		/**
+   * @memberOf FunctionBuilderBase#
    * @function
-   * @memberOf GPU#
+   * @name traceFunctionCalls
    *
-   * @param {Function} subKernels - Kernel function(s) to combine.
-   * @param {Function} rootKernel - Root kernel to combine kernels into
+   * @desc Trace all the depending functions being called, from a single function
    *
-   * @example
-   * 	combineKernels(add, multiply, function(a,b,c){
-   *	 	return add(multiply(a,b), c)
-   *	})
+   * This allow for 'unneeded' functions to be automatically optimized out.
+   * Note that the 0-index, is the starting function trace.
    *
-   * @returns {Function} Callable kernel function
+   * @param {String} functionName - Function name to trace from, default to 'kernel'
+   * @param {String[]} retList - Returning list of function names that is traced. Including itself.
+   * @param {Object} [parent] - Parent node
    *
+   * @returns {String[]}  Returning list of function names that is traced. Including itself.
    */
 
 	}, {
-		key: 'combineKernels',
-		value: function combineKernels() {
-			var lastKernel = arguments[arguments.length - 2];
-			var combinedKernel = arguments[arguments.length - 1];
-			if (this.getMode() === 'cpu') return combinedKernel;
-
-			var canvas = arguments[0].getCanvas();
-			var webGl = arguments[0].getWebGl();
+		key: 'traceFunctionCalls',
+		value: function traceFunctionCalls(functionName, retList, parent) {
+			functionName = functionName || 'kernel';
+			retList = retList || [];
 
-			for (var i = 0; i < arguments.length - 1; i++) {
-				arguments[i].setCanvas(canvas).setWebGl(webGl).setOutputToTexture(true);
+			var fNode = this.nodeMap[functionName];
+			if (fNode) {
+				// Check if function already exists
+				var functionIndex = retList.indexOf(functionName);
+				if (functionIndex === -1) {
+					retList.push(functionName);
+					if (parent) {
+						fNode.parent = parent;
+					}
+					fNode.getFunctionString(); //ensure JS trace is done
+					for (var i = 0; i < fNode.calledFunctions.length; ++i) {
+						this.traceFunctionCalls(fNode.calledFunctions[i], retList, fNode);
+					}
+				} else {
+					/**
+      * https://github.com/gpujs/gpu.js/issues/207
+      * if dependent function is already in the list, because a function depends on it, and because it has
+      * already been traced, we know that we must move the dependent function to the end of the the retList.
+      * */
+					var dependantFunctionName = retList.splice(functionIndex, 1)[0];
+					retList.push(dependantFunctionName);
+				}
 			}
 
-			return function () {
-				combinedKernel.apply(null, arguments);
-				var texSize = lastKernel.texSize;
-				var gl = lastKernel.getWebGl();
-				var threadDim = lastKernel.threadDim;
-				var result = void 0;
-				if (lastKernel.floatOutput) {
-					result = new Float32Array(texSize[0] * texSize[1] * 4);
-					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.FLOAT, result);
+			if (this.nativeFunctions[functionName]) {
+				if (retList.indexOf(functionName) >= 0) {
+					// Does nothing if already traced
 				} else {
-					var bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
-					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
-					result = new Float32Array(bytes.buffer);
+					retList.push(functionName);
 				}
+			}
 
-				result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
-
-				if (lastKernel.output.length === 1) {
-					return result;
-				} else if (lastKernel.output.length === 2) {
-					return utils.splitArray(result, lastKernel.output[0]);
-				} else if (lastKernel.output.length === 3) {
-					var cube = utils.splitArray(result, lastKernel.output[0] * lastKernel.output[1]);
-					return cube.map(function (x) {
-						return utils.splitArray(x, lastKernel.output[0]);
-					});
-				}
-			};
+			return retList;
 		}
 
 		/**
+   * @memberOf FunctionBuilderBase#
+   * @function
+   * @name addKernel
    *
-   * Adds additional functions, that the kernel may call.
+   * @desc Add a new kernel to this instance
    *
-   * @name addFunction
-   * @function
-   * @memberOf GPU#
+   * @param {String} fnString - Kernel function as a String
+   * @param {Object} options - Settings object to set constants, debug mode, etc.
+   * @param {Array} paramNames - Parameters of the kernel
+   * @param {Array} paramTypes - Types of the parameters
    *
-   * @param {Function|String} fn - JS Function to do conversion
-   * @param {String[]|Object} paramTypes - Parameter type array, assumes all parameters are 'float' if null
-   * @param {String} returnType - The return type, assumes 'float' if null
    *
-   * @returns {GPU} returns itself
+   * @returns {Object} The inserted kernel as a Kernel Node
    *
    */
 
 	}, {
-		key: 'addFunction',
-		value: function addFunction(fn, paramTypes, returnType) {
-			this._runner.functionBuilder.addFunction(null, fn, paramTypes, returnType);
-			return this;
+		key: 'addKernel',
+		value: function addKernel(fnString, options, paramNames, paramTypes) {
+			var kernelNode = new this.Node('kernel', fnString, options, paramTypes);
+			kernelNode.setAddFunction(this.addFunction.bind(this));
+			kernelNode.paramNames = paramNames;
+			kernelNode.paramTypes = paramTypes;
+			kernelNode.isRootKernel = true;
+			this.addFunctionNode(kernelNode);
+			return kernelNode;
 		}
 
 		/**
-   *
-   * Adds additional native functions, that the kernel may call.
-   *
-   * @name addNativeFunction
+   * @memberOf FunctionBuilderBase#
    * @function
-   * @memberOf GPU#
+   * @name addSubKernel
    *
-   * @param {String} name - native function name, used for reverse lookup
-   * @param {String} nativeFunction - the native function implementation, as it would be defined in it's entirety
+   * @desc Add a new sub-kernel to the current kernel instance
    *
-   * @returns {GPU} returns itself
+   * @param {Function} jsFunction - Sub-kernel function (JavaScript)
+   * @param {Object} options - Settings object to set constants, debug mode, etc.
+   * @param {Array} paramNames - Parameters of the sub-kernel
+   * @param {Array} returnType - Return type of the subKernel
+   *
+   * @returns {Object} The inserted sub-kernel as a Kernel Node
    *
    */
 
 	}, {
-		key: 'addNativeFunction',
-		value: function addNativeFunction(name, nativeFunction) {
-			this._runner.functionBuilder.addNativeFunction(name, nativeFunction);
-			return this;
+		key: 'addSubKernel',
+		value: function addSubKernel(jsFunction, options, paramTypes, returnType) {
+			var kernelNode = new this.Node(null, jsFunction, options, paramTypes, returnType);
+			kernelNode.setAddFunction(this.addFunction.bind(this));
+			kernelNode.isSubKernel = true;
+			this.addFunctionNode(kernelNode);
+			return kernelNode;
 		}
 
 		/**
-   *
-   * Return the current mode in which gpu.js is executing.
-   * @name getMode
+   * @memberOf CPUFunctionBuilder#
+   * @name getPrototypeString
    * @function
-   * @memberOf GPU#
    *
-   * @returns {String} The current mode, "cpu", "webgl", etc.
+   * @desc Return the string for a function
+   *
+   * @param {String} functionName - Function name to trace from. If null, it returns the WHOLE builder stack
+   *
+   * @returns {String} The full string, of all the various functions. Trace optimized if functionName given
    *
    */
 
 	}, {
-		key: 'getMode',
-		value: function getMode() {
-			return this._runner.getMode();
+		key: 'getPrototypeString',
+		value: function getPrototypeString(functionName) {
+			return this.getPrototypes(functionName).join('\n');
 		}
 
 		/**
-   *
-   * Return TRUE, if browser supports WebGl AND Canvas
-   *
-   * @name get isWebGlSupported
+   * @memberOf CPUFunctionBuilder#
+   * @name getPrototypeString
    * @function
-   * @memberOf GPU#
    *
-   * Note: This function can also be called directly `GPU.isWebGlSupported()`
+   * @desc Return the string for a function
    *
-   * @returns {Boolean} TRUE if browser supports webGl
+   * @param {String} [functionName] - Function name to trace from. If null, it returns the WHOLE builder stack
+   *
+   * @returns {Array} The full string, of all the various functions. Trace optimized if functionName given
    *
    */
 
 	}, {
-		key: 'isWebGlSupported',
-		value: function isWebGlSupported() {
-			return utils.isWebGlSupported();
+		key: 'getPrototypes',
+		value: function getPrototypes(functionName) {
+			this.rootKernel.generate();
+			if (functionName) {
+				return this.getPrototypesFromFunctionNames(this.traceFunctionCalls(functionName, []).reverse());
+			}
+			return this.getPrototypesFromFunctionNames(Object.keys(this.nodeMap));
 		}
 
 		/**
+   * @memberOf FunctionBuilderBase#
+   * @function
+   * @name getStringFromFunctionNames
    *
-   * Return the canvas object bound to this gpu instance.
+   * @desc Get string from function names
    *
-   * @name getCanvas
-   * @function
-   * @memberOf GPU#
+   * @param {String[]} functionList - List of function to build string
    *
-   * @returns {Object} Canvas object if present
+   * @returns {String} The string, of all the various functions. Trace optimized if functionName given
    *
    */
 
 	}, {
-		key: 'getCanvas',
-		value: function getCanvas() {
-			return this._canvas;
+		key: 'getStringFromFunctionNames',
+		value: function getStringFromFunctionNames(functionList) {
+			var ret = [];
+			for (var i = 0; i < functionList.length; ++i) {
+				var node = this.nodeMap[functionList[i]];
+				if (node) {
+					ret.push(this.nodeMap[functionList[i]].getFunctionString());
+				}
+			}
+			return ret.join('\n');
 		}
 
 		/**
-   *
-   * Return the webGl object bound to this gpu instance.
-   *
-   * @name getWebGl
+   * @memberOf FunctionBuilderBase#
    * @function
-   * @memberOf GPU#
+   * @name getPrototypeStringFromFunctionNames
    *
-   * @returns {Object} WebGl object if present
+   * @desc Return string of all functions converted
    *
-   */
-
-	}, {
-		key: 'getWebGl',
-		value: function getWebGl() {
-			return this._webGl;
-		}
-	}]);
-
-	return GPU;
-}(GPUCore);
-
-;
-
-// This ensure static methods are "inherited"
-// See: https://stackoverflow.com/questions/5441508/how-to-inherit-static-methods-from-base-class-in-javascript
-Object.assign(GPU, GPUCore);
-
-module.exports = GPU;
-},{"../backend/cpu/runner":54,"../backend/web-gl/runner":64,"../backend/web-gl/validator-kernel":67,"./gpu-core":69,"./utils":74}],71:[function(require,module,exports){
-"use strict";
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-module.exports = function Input(value, size) {
-	_classCallCheck(this, Input);
-
-	this.value = value;
-	if (Array.isArray(size)) {
-		this.size = [];
-		for (var i = 0; i < size.length; i++) {
-			this.size[i] = size[i];
-		}
-		while (this.size.length < 3) {
-			this.size.push(1);
-		}
-	} else {
-		if (size.z) {
-			this.size = [size.x, size.y, size.z];
-		} else if (size.y) {
-			this.size = [size.x, size.y, 1];
-		} else {
-			this.size = [size.x, 1, 1];
-		}
-	}
-};
-},{}],72:[function(require,module,exports){
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var gpu = null;
-
-module.exports = function () {
-
-	/**
-  * @desc WebGl Texture implementation in JS
-  * @constructor Texture
-  * @param {Object} texture 
-  * @param {Array} size 
-  * @param {Array} output
-  * @param {Object} webGl
-  */
-	function Texture(texture, size, output, webGl) {
-		_classCallCheck(this, Texture);
-
-		this.texture = texture;
-		this.size = size;
-		this.output = output;
-		this.webGl = webGl;
-		this.kernel = null;
-	}
-
-	/**
-  * @name toArray
-  * @function
-  * @memberOf Texture#
-  *
-  * @desc Converts the Texture into a JavaScript Array.
-  * 
-  * @param {Object} The `gpu` Object
-  *
-  */
-
+   * @param {String[]} functionList - List of function names to build the string.
+   * @param {Object} [opt - Settings object passed to functionNode. See functionNode for more details.
+   *
+   * @returns {Array} Prototypes of all functions converted
+   *
+   */
 
-	_createClass(Texture, [{
-		key: 'toArray',
-		value: function toArray(gpu) {
-			if (!gpu) throw new Error('You need to pass the GPU object for toArray to work.');
-			if (this.kernel) return this.kernel(this);
+	}, {
+		key: 'getPrototypesFromFunctionNames',
+		value: function getPrototypesFromFunctionNames(functionList, opt) {
+			var ret = [];
+			for (var i = 0; i < functionList.length; ++i) {
+				var functionName = functionList[i];
+				var node = this.nodeMap[functionName];
+				if (node) {
+					ret.push(node.getFunctionPrototypeString(opt));
+				} else if (this.nativeFunctions[functionName]) {
+					ret.push(this.nativeFunctions[functionName]);
+				}
+			}
+			return ret;
+		}
 
-			this.kernel = gpu.createKernel(function (x) {
-				return x[this.thread.z][this.thread.y][this.thread.x];
-			}).setOutput(this.output);
+		/**
+   * @memberOf FunctionBuilderBase#
+   * @function
+   * @name getPrototypeStringFromFunctionNames
+   *
+   * @desc Return string of all functions converted
+   *
+   * @param {String[]} functionList - List of function names to build the string.
+   * @param {Object} opt - Settings object passed to functionNode. See functionNode for more details.
+   *
+   * @returns {String} Prototype string of all functions converted
+   *
+   */
 
-			return this.kernel(this);
+	}, {
+		key: 'getPrototypeStringFromFunctionNames',
+		value: function getPrototypeStringFromFunctionNames(functionList, opt) {
+			return this.getPrototypesFromFunctionNames(functionList, opt).toString();
 		}
 
 		/**
-   * @name delete
-   * @desc Deletes the Texture.
+   * @memberOf FunctionBuilderBase#
    * @function
-   * @memberOf Texture#
+   * @name getString
+   *
+   * Get string for a particular function name
    *
+   * @param {String} functionName - Function name to trace from. If null, it returns the WHOLE builder stack
+   *
+   * @returns {String} The string, of all the various functions. Trace optimized if functionName given
    *
    */
 
 	}, {
-		key: 'delete',
-		value: function _delete() {
-			return this.webGl.deleteTexture(this.texture);
+		key: 'getString',
+		value: function getString(functionName, opt) {
+			if (opt === undefined) {
+				opt = {};
+			}
+
+			if (functionName) {
+				return this.getStringFromFunctionNames(this.traceFunctionCalls(functionName, [], opt).reverse(), opt);
+			}
+			return this.getStringFromFunctionNames(Object.keys(this.nodeMap), opt);
+		}
+	}, {
+		key: 'polyfillStandardFunctions',
+		value: function polyfillStandardFunctions() {
+			throw new Error('polyfillStandardFunctions not defined on base function builder');
 		}
 	}]);
 
-	return Texture;
+	return FunctionBuilderBase;
 }();
-},{}],73:[function(require,module,exports){
+},{}],57:[function(require,module,exports){
 'use strict';
 
-/**
- *
- * @desc Reduced subset of Utils, used exclusively in gpu-core.js
- * Various utility functions / snippets of code that GPU.JS uses internally.\
- * This covers various snippets of code that is not entirely gpu.js specific (ie. may find uses elsewhere)
- *
- * Note that all methods in this class is 'static' by nature `UtilsCore.functionName()`
- *
- * @class UtilsCore
- *
- */
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var UtilsCore = function () {
-	function UtilsCore() {
-		_classCallCheck(this, UtilsCore);
-	}
+var utils = require('../core/utils');
+var acorn = require('acorn');
 
-	_createClass(UtilsCore, null, [{
-		key: 'isCanvas',
+module.exports = function () {
 
+	/**
+  * @constructor FunctionNodeBase
+  * 
+  * @desc Represents a single function, inside JS, webGL, or openGL.
+  * 
+  * <p>This handles all the raw state, converted state, etc. Of a single function.</p>
+  * 
+  * @prop {String} functionName - Name of the function
+  * @prop {Function} jsFunction - The JS Function the node represents
+  * @prop {String} jsFunctionString - jsFunction.toString()
+  * @prop {String[]} paramNames - Parameter names of the function
+  * @prop {String[]} paramTypes - Shader land parameters type assumption
+  * @prop {Boolean} isRootKernel - Special indicator, for kernel function
+  * @prop {String} webglFunctionString - webgl converted function string
+  * @prop {String} openglFunctionString - opengl converted function string
+  * @prop {String[]} calledFunctions - List of all the functions called
+  * @prop {String[]} initVariables - List of variables initialized in the function
+  * @prop {String[]} readVariables - List of variables read operations occur
+  * @prop {String[]} writeVariables - List of variables write operations occur
+  * 
+  * @param {GPU} gpu - The GPU instance
+  * @param {String} functionName - Function name to assume, if its null, it attempts to extract from the function
+  * @param {Function|String} jsFunction - JS Function to do conversion
+  * @param {String[]|Object} paramTypes - Parameter type array, assumes all parameters are 'float' if null
+  * @param {String} returnType - The return type, assumes 'float' if null
+  *
+  */
+	function BaseFunctionNode(functionName, jsFunction, options, paramTypes, returnType) {
+		_classCallCheck(this, BaseFunctionNode);
 
-		/**
-   * @typedef {Object} webGlContext
-   */
+		//
+		// Internal vars setup
+		//
+		this.calledFunctions = [];
+		this.calledFunctionsArguments = {};
+		this.initVariables = [];
+		this.readVariables = [];
+		this.writeVariables = [];
+		this.addFunction = null;
+		this.isRootKernel = false;
+		this.isSubKernel = false;
+		this.parent = null;
+		this.debug = null;
+		this.prototypeOnly = null;
+		this.constants = null;
+		this.output = null;
 
-		/**
-   * @typedef {Object} CanvasDOMObject
-   */
+		if (options) {
+			if (options.hasOwnProperty('debug')) {
+				this.debug = options.debug;
+			}
+			if (options.hasOwnProperty('prototypeOnly')) {
+				this.prototypeOnly = options.prototypeOnly;
+			}
+			if (options.hasOwnProperty('constants')) {
+				this.constants = options.constants;
+			}
+			if (options.hasOwnProperty('output')) {
+				this.output = options.output;
+			}
+			if (options.hasOwnProperty('loopMaxIterations')) {
+				this.loopMaxIterations = options.loopMaxIterations;
+			}
+		}
 
-		//-----------------------------------------------------------------------------
 		//
-		//  Canvas validation and support
+		// Missing jsFunction object exception
 		//
-		//-----------------------------------------------------------------------------
-
-		/**
-   * @name isCanvas
-   * @static
-   * @function
-   * @memberOf UtilsCore
-   *
-   *
-   * @desc Return TRUE, on a valid DOM canvas object
-   *
-   * Note: This does just a VERY simply sanity check. And may give false positives.
-   *
-   * @param {CanvasDOMObject} canvasObj - Object to validate
-   *
-   * @returns {Boolean} TRUE if the object is a DOM canvas
-   *
-   */
-		value: function isCanvas(canvasObj) {
-			return canvasObj !== null && canvasObj.nodeName && canvasObj.getContext && canvasObj.nodeName.toUpperCase() === 'CANVAS';
+		if (!jsFunction) {
+			throw 'jsFunction, parameter is missing';
 		}
 
-		/**
-   * @name isCanvasSupported
-   * @function
-   * @static
-   * @memberOf UtilsCore
-   *
-   * @desc Return TRUE, if browser supports canvas
-   *
-   * @returns {Boolean} TRUE if browser supports canvas
-   *
-   */
+		//
+		// Setup jsFunction and its string property + validate them
+		//
+		this.jsFunctionString = jsFunction.toString();
+		if (!utils.isFunctionString(this.jsFunctionString)) {
+			console.error('jsFunction, to string conversion check failed: not a function?', this.jsFunctionString);
+			throw 'jsFunction, to string conversion check failed: not a function?';
+		}
 
-	}, {
-		key: 'isCanvasSupported',
-		value: function isCanvasSupported() {
-			return _isCanvasSupported;
+		if (!utils.isFunction(jsFunction)) {
+			//throw 'jsFunction, is not a valid JS Function';
+			this.jsFunction = null;
+		} else {
+			this.jsFunction = jsFunction;
 		}
 
-		/**
-   * @name initCanvas
-   * @function
-   * @static
-   * @memberOf UtilsCore
-   *
-   * @desc Initiate and returns a canvas, for usage in init_webgl.
-   * Returns only if canvas is supported by browser.
-   *
-   * @returns {CanvasDOMObject} CanvasDOMObject if supported by browser, else null
-   *
-   */
+		//
+		// Setup the function name property
+		//
+		this.functionName = functionName || jsFunction && jsFunction.name || utils.getFunctionNameFromString(this.jsFunctionString);
 
-	}, {
-		key: 'initCanvas',
-		value: function initCanvas() {
-			// Fail fast if browser previously detected no support
-			if (!_isCanvasSupported) {
-				return null;
+		if (!this.functionName) {
+			throw 'jsFunction, missing name argument or value';
+		}
+
+		//
+		// Extract parameter name, and its argument types
+		//
+		this.paramNames = utils.getParamNamesFromString(this.jsFunctionString);
+		if (paramTypes) {
+			if (Array.isArray(paramTypes)) {
+				if (paramTypes.length !== this.paramNames.length) {
+					throw 'Invalid argument type array length, against function length -> (' + paramTypes.length + ',' + this.paramNames.length + ')';
+				}
+				this.paramTypes = paramTypes;
+			} else if ((typeof paramTypes === 'undefined' ? 'undefined' : _typeof(paramTypes)) === 'object') {
+				var paramVariableNames = Object.keys(paramTypes);
+				if (paramTypes.hasOwnProperty('returns')) {
+					this.returnType = paramTypes.returns;
+					paramVariableNames.splice(paramVariableNames.indexOf('returns'), 1);
+				}
+				if (paramVariableNames.length > 0 && paramVariableNames.length !== this.paramNames.length) {
+					throw 'Invalid argument type array length, against function length -> (' + paramVariableNames.length + ',' + this.paramNames.length + ')';
+				} else {
+					this.paramTypes = this.paramNames.map(function (key) {
+						if (paramTypes.hasOwnProperty(key)) {
+							return paramTypes[key];
+						} else {
+							return 'float';
+						}
+					});
+				}
 			}
-
-			// Create a new canvas DOM
-			var canvas = document.createElement('canvas');
-
-			// Default width and height, to fix webgl issue in safari
-			canvas.width = 2;
-			canvas.height = 2;
-
-			// Returns the canvas
-			return canvas;
+		} else {
+			this.paramTypes = [];
+			//TODO: Remove when we have proper type detection
+			// for (let a = 0; a < this.paramNames.length; ++a) {
+			// 	this.paramTypes.push();
+			// }
 		}
 
-		//-----------------------------------------------------------------------------
 		//
-		//  Webgl validation and support
+		// Return type handling
 		//
-		//-----------------------------------------------------------------------------
-
-
-		/**
-   *
-   * @name isWebGl
-   * @function
-   * @static
-   * @memberOf UtilsCore
-   *
-   * @desc Return TRUE, on a valid webGlContext object
-   *
-   * Note: This does just a VERY simply sanity check. And may give false positives.
-   *
-   * @param {webGlContext} webGlObj - Object to validate
-   *
-   * @returns {Boolean} TRUE if the object is a webGlContext object
-   *
-   */
+		if (!this.returnType) {
+			this.returnType = returnType || 'float';
+		}
+	}
 
+	_createClass(BaseFunctionNode, [{
+		key: 'isIdentifierConstant',
+		value: function isIdentifierConstant(paramName) {
+			if (!this.constants) return false;
+			return this.constants.hasOwnProperty(paramName);
+		}
 	}, {
-		key: 'isWebGl',
-		value: function isWebGl(webGlObj) {
-			return webGlObj && typeof webGlObj.getExtension === 'function';
+		key: 'setAddFunction',
+		value: function setAddFunction(fn) {
+			this.addFunction = fn;
+			return this;
 		}
+		/**
+   * 
+   * Core Functions
+   * 
+   */
 
 		/**
-   * @name isWebGlSupported
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
-   * @memberOf UtilsCore
+   * @name getJSFunction
    *
-   * @desc Return TRUE, if browser supports webgl
+   * @desc Gets and return the stored JS Function.
+   * Note: that this internally eval the function, if only the string was provided on construction
    *
-   * @returns {Boolean} TRUE if browser supports webgl
+   * @returns {Function} The function object
    *
    */
 
 	}, {
-		key: 'isWebGlSupported',
-		value: function isWebGlSupported() {
-			return _isWebGlSupported;
-		}
-	}, {
-		key: 'isWebGlDrawBuffersSupported',
-		value: function isWebGlDrawBuffersSupported() {
-			return _isWebGlDrawBuffersSupported;
-		}
+		key: 'getJsFunction',
+		value: function getJsFunction() {
+			if (this.jsFunction) {
+				return this.jsFunction;
+			}
 
-		// Default webgl options to use
+			if (this.jsFunctionString) {
+				this.jsFunction = eval(this.jsFunctionString);
+				return this.jsFunction;
+			}
 
-	}, {
-		key: 'initWebGlDefaultOptions',
-		value: function initWebGlDefaultOptions() {
-			return {
-				alpha: false,
-				depth: false,
-				antialias: false
-			};
+			throw 'Missing jsFunction, and jsFunctionString parameter';
 		}
 
 		/**
-   * @name initWebGl
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
-   * @memberOf UtilsCore
-   *
-   * @desc Initiate and returns a webGl, from a canvas object
-   * Returns only if webGl is supported by browser.
+   * @name astMemberExpressionUnroll
+   * @desc Parses the abstract syntax tree for binary expression.
    *
-   * @param {CanvasDOMObject} canvasObj - Object to validate
+   * <p>Utility function for astCallExpression.</p>
    *
-   * @returns {CanvasDOMObject} CanvasDOMObject if supported by browser, else null
+   * @param {Object} ast - the AST object to parse
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
    *
+   * @returns {String} the function namespace call, unrolled
    */
 
 	}, {
-		key: 'initWebGl',
-		value: function initWebGl(canvasObj) {
-
-			// First time setup, does the browser support check memorizer
-			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
-				if (!_isCanvasSupported) {
-					return null;
-				}
-			}
-
-			// Fail fast for invalid canvas object
-			if (!UtilsCore.isCanvas(canvasObj)) {
-				throw new Error('Invalid canvas object - ' + canvasObj);
+		key: 'astMemberExpressionUnroll',
+		value: function astMemberExpressionUnroll(ast, funcParam) {
+			if (ast.type === 'Identifier') {
+				return ast.name;
+			} else if (ast.type === 'ThisExpression') {
+				return 'this';
 			}
 
-			// Create a new canvas DOM
-			var webGl = canvasObj.getContext('experimental-webgl', UtilsCore.initWebGlDefaultOptions()) || canvasObj.getContext('webgl', UtilsCore.initWebGlDefaultOptions());
+			if (ast.type === 'MemberExpression') {
+				if (ast.object && ast.property) {
+					//babel sniffing
+					if (ast.object.hasOwnProperty('name') && ast.object.name[0] === '_') {
+						return this.astMemberExpressionUnroll(ast.property, funcParam);
+					}
 
-			if (webGl) {
-				// Get the extension that is needed
-				webGl.OES_texture_float = webGl.getExtension('OES_texture_float');
-				webGl.OES_texture_float_linear = webGl.getExtension('OES_texture_float_linear');
-				webGl.OES_element_index_uint = webGl.getExtension('OES_element_index_uint');
+					return this.astMemberExpressionUnroll(ast.object, funcParam) + '.' + this.astMemberExpressionUnroll(ast.property, funcParam);
+				}
 			}
 
-			// Returns the canvas
-			return webGl;
-		}
-	}]);
-
-	return UtilsCore;
-}();
-
-//-----------------------------------------------------------------------------
-//
-//  Canvas & Webgl validation and support constants
-//
-//-----------------------------------------------------------------------------
-
-var _isCanvasSupported = typeof document !== 'undefined' ? UtilsCore.isCanvas(document.createElement('canvas')) : false;
-var _testingWebGl = UtilsCore.initWebGl(UtilsCore.initCanvas());
-var _isWebGlSupported = UtilsCore.isWebGl(_testingWebGl);
-var _isWebGlDrawBuffersSupported = _isWebGlSupported && Boolean(_testingWebGl.getExtension('WEBGL_draw_buffers'));
-
-if (_isWebGlSupported) {
-	UtilsCore.OES_texture_float = _testingWebGl.OES_texture_float;
-	UtilsCore.OES_texture_float_linear = _testingWebGl.OES_texture_float_linear;
-	UtilsCore.OES_element_index_uint = _testingWebGl.OES_element_index_uint;
-} else {
-	UtilsCore.OES_texture_float = false;
-	UtilsCore.OES_texture_float_linear = false;
-	UtilsCore.OES_element_index_uint = false;
-}
-
-module.exports = UtilsCore;
-},{}],74:[function(require,module,exports){
-'use strict';
-
-/**
- * 
- * @classdesc Various utility functions / snippets of code that GPU.JS uses internally.\
- * This covers various snippets of code that is not entirely gpu.js specific (ie. may find uses elsewhere)
- *
- * Note that all methods in this class are *static* by nature `Utils.functionName()`
- * 
- * @class Utils
- * @extends UtilsCore
- *
- */
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var UtilsCore = require("./utils-core");
-var Input = require('./input');
-var Texture = require('./texture');
-// FUNCTION_NAME regex
-var FUNCTION_NAME = /function ([^(]*)/;
-
-// STRIP COMMENTS regex
-var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-
-// ARGUMENT NAMES regex
-var ARGUMENT_NAMES = /([^\s,]+)/g;
-
-var _systemEndianness = function () {
-	var b = new ArrayBuffer(4);
-	var a = new Uint32Array(b);
-	var c = new Uint8Array(b);
-	a[0] = 0xdeadbeef;
-	if (c[0] === 0xef) return 'LE';
-	if (c[0] === 0xde) return 'BE';
-	throw new Error('unknown endianness');
-}();
-
-var _isFloatReadPixelsSupported = null;
-
-var _isMixedIdentifiersSupported = function () {
-	try {
-		new Function('let i = 1; const j = 1;')();
-		return true;
-	} catch (e) {
-		return false;
-	}
-}();
+			//babel sniffing
+			if (ast.hasOwnProperty('expressions')) {
+				var firstExpression = ast.expressions[0];
+				if (firstExpression.type === 'Literal' && firstExpression.value === 0 && ast.expressions.length === 2) {
+					return this.astMemberExpressionUnroll(ast.expressions[1]);
+				}
+			}
 
-var Utils = function (_UtilsCore) {
-	_inherits(Utils, _UtilsCore);
+			// Failure, unknown expression
+			throw this.astErrorOutput('Unknown CallExpression_unroll', ast, funcParam);
+		}
 
-	function Utils() {
-		_classCallCheck(this, Utils);
+		/**
+   * @memberOf FunctionNodeBase#
+   * @function
+   * @name getJsAST
+   *
+   * @desc Parses the class function JS, and returns its Abstract Syntax Tree object.
+   *
+   * This is used internally to convert to shader code
+   *
+   * @param {JISONParser} inParser - Parser to use, assumes in scope 'parser' if null
+   *
+   * @returns {ASTObject} The function AST Object, note that result is cached under this.jsFunctionAST;
+   *
+   */
 
-		return _possibleConstructorReturn(this, (Utils.__proto__ || Object.getPrototypeOf(Utils)).apply(this, arguments));
-	}
+	}, {
+		key: 'getJsAST',
+		value: function getJsAST(inParser) {
+			if (this.jsFunctionAST) {
+				return this.jsFunctionAST;
+			}
 
-	_createClass(Utils, null, [{
-		key: 'systemEndianness',
+			inParser = inParser || acorn;
+			if (inParser === null) {
+				throw 'Missing JS to AST parser';
+			}
 
+			var ast = inParser.parse('var ' + this.functionName + ' = ' + this.jsFunctionString + ';', {
+				locations: true
+			});
+			if (ast === null) {
+				throw 'Failed to parse JS code';
+			}
 
-		//-----------------------------------------------------------------------------
-		//
-		//  System values support (currently only endianness)
-		//
-		//-----------------------------------------------------------------------------
+			// take out the function object, outside the var declarations
+			var funcAST = ast.body[0].declarations[0].init;
+			this.jsFunctionAST = funcAST;
+
+			return funcAST;
+		}
 
 		/**
-   * @memberOf Utils
-   * @name systemEndianness
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
+   * @name getFunctionString
    *
-   * Gets the system endianness, and cache it
+   * @desc Returns the converted webgl shader function equivalent of the JS function
    *
-   * @returns {String} 'LE' or 'BE' depending on system architecture
+   * @returns {String} webgl function string, result is cached under this.webGlFunctionString
    *
-   * Credit: https://gist.github.com/TooTallNate/4750953
    */
-		value: function systemEndianness() {
-			return _systemEndianness;
-		}
 
-		//-----------------------------------------------------------------------------
-		//
-		//  Function and function string validations
-		//
-		//-----------------------------------------------------------------------------
+	}, {
+		key: 'getFunctionString',
+		value: function getFunctionString() {
+			this.generate();
+			return this.functionString;
+		}
 
 		/**
-   * @memberOf Utils
-   * @name isFunction
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
-   *
-   * Return TRUE, on a JS function
+   * @name setFunctionString
    *
-   * @param {Function} funcObj - Object to validate if its a function
+   * @desc Set the functionString value, overwriting it
    *
-   * @returns	{Boolean} TRUE if the object is a JS function
+   * @param {String} functionString - Shader code string, representing the function
    *
    */
 
 	}, {
-		key: 'isFunction',
-		value: function isFunction(funcObj) {
-			return typeof funcObj === 'function';
+		key: 'setFunctionString',
+		value: function setFunctionString(functionString) {
+			this.functionString = functionString;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name isFunctionString
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
-   *
-   * Return TRUE, on a valid JS function string
+   * @name getParamType
    *
-   * Note: This does just a VERY simply sanity check. And may give false positives.
+   * @desc Return the type of parameter sent to subKernel/Kernel.
    *
-   * @param {String} funcStr - String of JS function to validate
+   * @param {String} paramName - Name of the parameter
    *
-   * @returns {Boolean} TRUE if the string passes basic validation
+   * @returns {String} Type of the parameter
    *
    */
 
 	}, {
-		key: 'isFunctionString',
-		value: function isFunctionString(funcStr) {
-			if (funcStr !== null) {
-				return funcStr.toString().slice(0, 'function'.length).toLowerCase() === 'function';
+		key: 'getParamType',
+		value: function getParamType(paramName) {
+			var paramIndex = this.paramNames.indexOf(paramName);
+			if (paramIndex === -1) return null;
+			if (!this.parent) return null;
+			if (this.paramTypes[paramIndex]) return this.paramTypes[paramIndex];
+			var calledFunctionArguments = this.parent.calledFunctionsArguments[this.functionName];
+			for (var i = 0; i < calledFunctionArguments.length; i++) {
+				var calledFunctionArgument = calledFunctionArguments[i];
+				if (calledFunctionArgument[paramIndex] !== null) {
+					return this.paramTypes[paramIndex] = calledFunctionArgument[paramIndex].type;
+				}
 			}
-			return false;
+			return null;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name getFunctionName_fromString
+   * @memberOf FunctionNodeBase#
    * @function
-   * @static
+   * @name getUserParamName
    *
-   * Return the function name from a JS function string
+   * @desc Return the name of the *user parameter*(subKernel parameter) corresponding 
+   * to the parameter supplied to the kernel
    *
-   * @param {String} funcStr - String of JS function to validate
+   * @param {String} paramName - Name of the parameter
    *
-   * @returns {String} Function name string (if found)
+   * @returns {String} Name of the parameter
    *
    */
 
 	}, {
-		key: 'getFunctionNameFromString',
-		value: function getFunctionNameFromString(funcStr) {
-			return FUNCTION_NAME.exec(funcStr)[1];
+		key: 'getUserParamName',
+		value: function getUserParamName(paramName) {
+			var paramIndex = this.paramNames.indexOf(paramName);
+			if (paramIndex === -1) return null;
+			if (!this.parent) return null;
+			var calledFunctionArguments = this.parent.calledFunctionsArguments[this.functionName];
+			for (var i = 0; i < calledFunctionArguments.length; i++) {
+				var calledFunctionArgument = calledFunctionArguments[i];
+				if (calledFunctionArgument[paramIndex] !== null) {
+					return calledFunctionArgument[paramIndex].name;
+				}
+			}
+			return null;
+		}
+	}, {
+		key: 'generate',
+		value: function generate(options) {
+			throw new Error('generate not defined on BaseFunctionNode');
+		}
+
+		/**
+   * @function
+   * @name astErrorOutput
+   * @ignore
+   * @desc To throw the AST error, with its location.
+   *
+   * @todo add location support fpr the AST error
+   *
+   * @param {Object} error - the error message output
+   * @param {Object} ast - the AST object where the error is
+   * @param {Object} funcParam - FunctionNode, that tracks compilation state
+   */
+
+	}, {
+		key: 'astErrorOutput',
+		value: function astErrorOutput(error, ast, funcParam) {
+			console.error(utils.getAstString(this.jsFunctionString, ast));
+			console.error(error, ast, funcParam);
+			return error;
+		}
+	}, {
+		key: 'astDebuggerStatement',
+		value: function astDebuggerStatement(arrNode, retArr, funcParam) {
+			return retArr;
+		}
+	}]);
+
+	return BaseFunctionNode;
+}();
+},{"../core/utils":75,"acorn":45}],58:[function(require,module,exports){
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var utils = require('../core/utils');
+
+module.exports = function () {
+
+	/**
+  * @constructor BaseKernel
+  * 
+  * @desc Implements the base class for Kernels, and is used as a 
+  * parent class for all Kernel implementations.
+  *
+  * This contains the basic methods needed by all Kernel implementations, 
+  * like setDimensions, addSubKernel, etc.
+  * 
+  * @prop {Array} paramNames - Name of the parameters of the kernel function
+  * @prop {String} fnString - Kernel function as a String
+  * @prop {Array} dimensions - Dimensions of the kernel function, this.thread.x, etc.
+  * @prop {Boolean} debug - Toggle debug mode
+  * @prop {String} graphical - Toggle graphical mode
+  * @prop {number} loopMaxIterations - Maximum number of loop iterations
+  * @prop {Object} constants - Global constants
+  * @prop {Array} subKernels - Sub kernels bound to this kernel instance
+  * @prop {Object} subKernelProperties - Sub kernels bound to this kernel instance as key/value pairs
+  * @prop {Array} subKernelOutputVariableNames - Names of the variables outputted by the subkerls
+  *
+  */
+	function BaseKernel(fnString, settings) {
+		_classCallCheck(this, BaseKernel);
+
+		this.paramNames = utils.getParamNamesFromString(fnString);
+		this.fnString = fnString;
+		this.output = null;
+		this.debug = false;
+		this.graphical = false;
+		this.loopMaxIterations = 0;
+		this.constants = null;
+		this.wraparound = null;
+		this.hardcodeConstants = null;
+		this.outputToTexture = null;
+		this.texSize = null;
+		this._canvas = null;
+		this._webGl = null;
+		this.threadDim = null;
+		this.floatTextures = null;
+		this.floatOutput = null;
+		this.floatOutputForce = null;
+		this.addFunction = null;
+		this.functions = null;
+		this.nativeFunctions = null;
+		this.copyData = true;
+		this.subKernels = null;
+		this.subKernelProperties = null;
+		this.subKernelNames = null;
+		this.subKernelOutputVariableNames = null;
+		this.functionBuilder = null;
+		this.paramTypes = null;
+
+		for (var p in settings) {
+			if (!settings.hasOwnProperty(p) || !this.hasOwnProperty(p)) continue;
+			this[p] = settings[p];
+		}
+		if (settings.hasOwnProperty('canvas')) {
+			this._canvas = settings.canvas;
 		}
-	}, {
-		key: 'getFunctionBodyFromString',
-		value: function getFunctionBodyFromString(funcStr) {
-			return funcStr.substring(funcStr.indexOf('{') + 1, funcStr.lastIndexOf('}'));
+		if (settings.hasOwnProperty('output')) {
+			this.setOutput(settings.output); // Flatten output object
 		}
 
-		/**
-   * @memberOf Utils
-   * @name getParamNames_fromString
-   * @function
-   * @static
-   *
-   * Return list of parameter names extracted from the JS function string
-   *
-   * @param {String} funcStr - String of JS function to validate
-   *
-   * @returns {String[]}  Array representing all the parameter names
-   *
-   */
+		if (!this._canvas) this._canvas = utils.initCanvas();
+	}
 
-	}, {
-		key: 'getParamNamesFromString',
-		value: function getParamNamesFromString(func) {
-			var fnStr = func.toString().replace(STRIP_COMMENTS, '');
-			var result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
-			if (result === null) result = [];
-			return result;
+	_createClass(BaseKernel, [{
+		key: 'build',
+		value: function build() {
+			throw new Error('"build" not defined on Base');
 		}
 
-		//-----------------------------------------------------------------------------
-		//
-		//  Object / function cloning and manipulation
-		//
-		//-----------------------------------------------------------------------------
-
 		/**
-   * @memberOf Utils
-   * @name clone
+   * @memberOf KernelBase#
    * @function
-   * @static
-   *
-   * Returns a clone
+   * @name setupParams
    *
-   * @param {Object} obj - Object to clone
+   * @desc Setup the parameter types for the parameters
+   * supplied to the Kernel function
    *
-   * @returns {Object}  Cloned object
+   * @param {Array} args - The actual parameters sent to the Kernel
    *
    */
 
 	}, {
-		key: 'clone',
-		value: function clone(obj) {
-			if (obj === null || (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj.hasOwnProperty('isActiveClone')) return obj;
-
-			var temp = obj.constructor(); // changed
-
-			for (var key in obj) {
-				if (Object.prototype.hasOwnProperty.call(obj, key)) {
-					obj.isActiveClone = null;
-					temp[key] = Utils.clone(obj[key]);
-					delete obj.isActiveClone;
-				}
+		key: 'setupParams',
+		value: function setupParams(args) {
+			var paramTypes = this.paramTypes = [];
+			for (var i = 0; i < args.length; i++) {
+				var param = args[i];
+				var paramType = utils.getArgumentType(param);
+				paramTypes.push(paramType);
 			}
-
-			return temp;
+		}
+	}, {
+		key: 'setAddFunction',
+		value: function setAddFunction(cb) {
+			this.addFunction = cb;
+			return this;
+		}
+	}, {
+		key: 'setFunctions',
+		value: function setFunctions(functions) {
+			this.functions = functions;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name newPromise
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Returns a `new Promise` object based on the underlying implmentation
+   * @name setOutput
    *
-   * @param {Function} executor - Promise builder function
+   * @desc Set dimensions of the kernel function
    *
-   * @returns {Promise}  Promise object
+   * @param {Array|Object} output - The output array to set the kernel output size to
    *
    */
 
 	}, {
-		key: 'newPromise',
-		value: function newPromise(executor) {
-			var simple = Promise || small_promise;
-			if (simple === null) {
-				throw TypeError('Browser is missing Promise implementation. Consider adding small_promise.js polyfill');
+		key: 'setOutput',
+		value: function setOutput(output) {
+			if (output.hasOwnProperty('x')) {
+				if (output.hasOwnProperty('y')) {
+					if (output.hasOwnProperty('z')) {
+						this.output = [output.x, output.y, output.z];
+					} else {
+						this.output = [output.x, output.y];
+					}
+				} else {
+					this.output = [output.x];
+				}
+			} else {
+				this.output = output;
 			}
-			return new simple(executor);
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name functionBinder
+   * @memberOf BaseKernel# 
    * @function
-   * @static
-   *
-   * Limited implementation of Function.bind, with fallback
+   * @name setDebug
    *
-   * @param {Function} inFunc - to setup bind on
-   * @param {Object} thisObj - The this parameter to assume inside the binded function
+   * @desc Toggle debug mode
    *
-   * @returns {Function}  The binded function
+   * @param {Boolean} flag - true to enable debug
    *
    */
 
 	}, {
-		key: 'functionBinder',
-		value: function functionBinder(inFunc, thisObj) {
-			if (inFunc.bind) {
-				return inFunc.bind(thisObj);
-			}
-
-			return function () {
-				var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
-				return inFunc.apply(thisObj, args);
-			};
+		key: 'setDebug',
+		value: function setDebug(flag) {
+			this.debug = flag;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name isArray
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * * Checks if is an array or Array-like object
+   * @name setGraphical
    *
-   * @param {Object} arg - The argument object to check if is array
+   * @desc Toggle graphical output mode
    *
-   * @returns {Boolean}  true if is array or Array-like object
+   * @param {Boolean} flag - true to enable graphical output
    *
    */
 
 	}, {
-		key: 'isArray',
-		value: function isArray(array) {
-			if (isNaN(array.length)) {
-				return false;
-			}
-
-			return true;
+		key: 'setGraphical',
+		value: function setGraphical(flag) {
+			this.graphical = flag;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name getArgumentType
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Evaluate the argument type, to apply respective logic for it
+   * @name setLoopMaxIterations
    *
-   * @param {Object} arg - The argument object to evaluate type
+   * @desc Set the maximum number of loop iterations
    *
-   * @returns {String}  Argument type Array/Number/Texture/Unknown
+   * @param {number} max - iterations count
    *
    */
 
 	}, {
-		key: 'getArgumentType',
-		value: function getArgumentType(arg) {
-			if (Utils.isArray(arg)) {
-				return 'Array';
-			} else if (typeof arg === 'number') {
-				return 'Number';
-			} else if (arg instanceof Texture) {
-				return 'Texture';
-			} else if (arg instanceof Input) {
-				return 'Input';
-			} else {
-				return 'Unknown';
-			}
+		key: 'setLoopMaxIterations',
+		value: function setLoopMaxIterations(max) {
+			this.loopMaxIterations = max;
+			return this;
 		}
-		/**
-   * @typedef {Object} gpuJSObject
-   */
 
 		/**
-   * @memberOf Utils
-   * @name isFloatReadPixelsSupported
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Checks if the browser supports readPixels with float type
-   *
-   * @param {gpuJSObject} gpu - the gpu object
-   *
-   * @returns {Boolean} true if browser supports
-   *
+   * @name setConstants
+   * @desc Set Constants
    */
 
 	}, {
-		key: 'isFloatReadPixelsSupported',
-		value: function isFloatReadPixelsSupported() {
-			if (_isFloatReadPixelsSupported !== null) {
-				return _isFloatReadPixelsSupported;
-			}
-
-			var GPU = require('../index');
-			var x = new GPU({
-				mode: 'webgl-validator'
-			}).createKernel(function () {
-				return 1;
-			}, {
-				output: [2],
-				floatTextures: true,
-				floatOutput: true,
-				floatOutputForce: true
-			})();
-
-			_isFloatReadPixelsSupported = x[0] === 1;
-
-			return _isFloatReadPixelsSupported;
+		key: 'setConstants',
+		value: function setConstants(constants) {
+			this.constants = constants;
+			return this;
 		}
 	}, {
-		key: 'isMixedIdentifiersSupported',
-		value: function isMixedIdentifiersSupported() {
-			return _isMixedIdentifiersSupported;
+		key: 'setWraparound',
+		value: function setWraparound(flag) {
+			console.warn('Wraparound mode is not supported and undocumented.');
+			this.wraparound = flag;
+			return this;
 		}
 	}, {
-		key: 'dimToTexSize',
-		value: function dimToTexSize(opt, dimensions, output) {
-			var numTexels = dimensions[0];
-			for (var i = 1; i < dimensions.length; i++) {
-				numTexels *= dimensions[i];
-			}
-
-			if (opt.floatTextures && (!output || opt.floatOutput)) {
-				numTexels = Math.ceil(numTexels / 4);
-			}
-
-			var w = Math.ceil(Math.sqrt(numTexels));
-			return [w, w];
+		key: 'setHardcodeConstants',
+		value: function setHardcodeConstants(flag) {
+			this.hardcodeConstants = flag;
+			return this;
+		}
+	}, {
+		key: 'setOutputToTexture',
+		value: function setOutputToTexture(flag) {
+			this.outputToTexture = flag;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name getDimensions
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Return the dimension of an array.
-   * 
-   * @param {Array|String} x - The array
-   * @param {number} [pad] - To include padding in the dimension calculation [Optional]
+   * @name setFloatTextures
    *
+   * @desc Toggle texture output mode
    *
+   * @param {Boolean} flag - true to enable floatTextures
    *
    */
 
 	}, {
-		key: 'getDimensions',
-		value: function getDimensions(x, pad) {
-			var ret = void 0;
-			if (Utils.isArray(x)) {
-				var dim = [];
-				var temp = x;
-				while (Utils.isArray(temp)) {
-					dim.push(temp.length);
-					temp = temp[0];
-				}
-				ret = dim.reverse();
-			} else if (x instanceof Texture) {
-				ret = x.output;
-			} else if (x instanceof Input) {
-				ret = x.size;
-			} else {
-				throw 'Unknown dimensions of ' + x;
-			}
-
-			if (pad) {
-				ret = Utils.clone(ret);
-				while (ret.length < 3) {
-					ret.push(1);
-				}
-			}
-
-			return ret;
+		key: 'setFloatTextures',
+		value: function setFloatTextures(flag) {
+			this.floatTextures = flag;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name pad
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Pad an array AND its elements with leading and ending zeros
+   * @name setFloatOutput
    *
-   * @param {Array} arr - the array to pad zeros to
-   * @param {number} padding - amount of padding
+   * @desc Toggle output mode
    *
-   * @returns {Array} Array with leading and ending zeros, and all the elements padded by zeros.
+   * @param {Boolean} flag - true to enable float
    *
    */
 
 	}, {
-		key: 'pad',
-		value: function pad(arr, padding) {
-			function zeros(n) {
-				return Array.apply(null, new Array(n)).map(Number.prototype.valueOf, 0);
-			}
+		key: 'setFloatOutput',
+		value: function setFloatOutput(flag) {
+			this.floatOutput = flag;
+			return this;
+		}
+	}, {
+		key: 'setFloatOutputForce',
+		value: function setFloatOutputForce(flag) {
+			this.floatOutputForce = flag;
+			return this;
+		}
 
-			var len = arr.length + padding * 2;
+		/**
+   * @memberOf BaseKernel#
+   * @function
+   * @name setCanvas
+   *
+   * @desc Bind the canvas to kernel
+   * 
+   * @param {Canvas} canvas - Canvas to bind
+   *
+   */
 
-			var ret = arr.map(function (x) {
-				return [].concat(zeros(padding), x, zeros(padding));
-			});
+	}, {
+		key: 'setCanvas',
+		value: function setCanvas(canvas) {
+			this._canvas = canvas;
+			return this;
+		}
 
-			for (var i = 0; i < padding; i++) {
-				ret = [].concat([zeros(len)], ret, [zeros(len)]);
-			}
+		/**
+   * @memberOf BaseKernel#
+   * @function
+   * @name setCanvas
+   *
+   * @desc Bind the webGL instance to kernel
+   * 
+   * @param {Canvas} webGL - webGL instance to bind
+   *
+   */
 
-			return ret;
+	}, {
+		key: 'setWebGl',
+		value: function setWebGl(webGl) {
+			this._webGl = webGl;
+			return this;
+		}
+	}, {
+		key: 'setCopyData',
+		value: function setCopyData(copyData) {
+			this.copyData = copyData;
+			return this;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name flatten2dArrayTo
+   * @memberOf BaseKernel#
    * @function
-   * @static
+   * @name getCanvas()
+   *
+   * @desc Returns the current canvas instance bound to the kernel
    *
-   * Puts a nested 2d array into a one-dimensional target array
-   * @param {Array|*} array
-   * @param {Float32Array|Float64Array} target
    */
 
 	}, {
-		key: 'flatten2dArrayTo',
-		value: function flatten2dArrayTo(array, target) {
-			var offset = 0;
-			for (var y = 0; y < array.length; y++) {
-				target.set(array[y], offset);
-				offset += array[y].length;
-			}
+		key: 'getCanvas',
+		value: function getCanvas() {
+			return this._canvas;
 		}
 
 		/**
-   * @memberOf Utils
-   * @name flatten3dArrayTo
+   * @memberOf BaseKernel#
    * @function
-   * @static
+   * @name getWebGl()
+   *
+   * @desc Returns the current webGl instance bound to the kernel
    *
-   * Puts a nested 3d array into a one-dimensional target array
-   * @param {Array|*} array
-   * @param {Float32Array|Float64Array} target
    */
 
 	}, {
-		key: 'flatten3dArrayTo',
-		value: function flatten3dArrayTo(array, target) {
-			var offset = 0;
-			for (var z = 0; z < array.length; z++) {
-				for (var y = 0; y < array[z].length; y++) {
-					target.set(array[z][y], offset);
-					offset += array[z][y].length;
+		key: 'getWebGl',
+		value: function getWebGl() {
+			return this._webGl;
+		}
+	}, {
+		key: 'validateOptions',
+		value: function validateOptions() {
+			throw new Error('validateOptions not defined');
+		}
+	}, {
+		key: 'exec',
+		value: function exec() {
+			return this.execute.apply(this, arguments);
+		}
+	}, {
+		key: 'execute',
+		value: function execute() {
+			var _this = this;
+
+			//
+			// Prepare the required objects
+			//
+			var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+
+			//
+			// Setup and return the promise, and execute the function, in synchronous mode
+			//
+			return utils.newPromise(function (accept, reject) {
+				try {
+					accept(_this.run.apply(_this, args));
+				} catch (e) {
+					//
+					// Error : throw rejection
+					//
+					reject(e);
 				}
-			}
+			});
 		}
 
-		/**
-   * @memberOf Utils
-   * @name flatten3dArrayTo
+		/** 
+   * @memberOf BaseKernel#
    * @function
-   * @static
+   * @name addSubKernel
+   *
+   * @desc Add a sub kernel to the root kernel instance.
+   * This is what `createKernelMap` uses.
+   *
+   * @param {String} fnString - function (as a String) of the subKernel to add
    *
-   * Puts a nested 1d, 2d, or 3d array into a one-dimensional target array
-   * @param {Array|*} array
-   * @param {Float32Array|Float64Array} target
    */
 
 	}, {
-		key: 'flattenTo',
-		value: function flattenTo(array, target) {
-			if (Utils.isArray(array[0])) {
-				if (Utils.isArray(array[0][0])) {
-					Utils.flatten3dArrayTo(array, target);
-				} else {
-					Utils.flatten2dArrayTo(array, target);
-				}
-			} else {
-				target.set(array);
+		key: 'addSubKernel',
+		value: function addSubKernel(fnString) {
+			if (this.subKernels === null) {
+				this.subKernels = [];
+				this.subKernelNames = [];
 			}
+			this.subKernels.push(fnString);
+			this.subKernelNames.push(utils.getFunctionNameFromString(fnString));
+			return this;
 		}
 
-		/**
-   * @memberOf Utils
-   * @name splitArray
+		/** 
+   * @memberOf BaseKernel#
    * @function
-   * @static
-   *
-   * Splits an array into smaller arrays.
-   * Number of elements in one small chunk is given by `part`
+   * @name addSubKernelProperty
    *
-   * @param {Array} array - The array to split into chunks
-   * @param {Array} part - elements in one chunk
+   * @desc Add a sub kernel to the root kernel instance, indexed by a property name
+   * This is what `createKernelMap` uses.
    *
-  	 * @returns {Array} An array of smaller chunks
+   * @param {String} property - property key for the subKernel
+   * @param {String} fnString - function (as a String) of the subKernel to add
    *
    */
 
 	}, {
-		key: 'splitArray',
-		value: function splitArray(array, part) {
-			var result = [];
-			for (var i = 0; i < array.length; i += part) {
-				result.push(Array.prototype.slice.call(array, i, i + part));
+		key: 'addSubKernelProperty',
+		value: function addSubKernelProperty(property, fnString) {
+			if (this.subKernelProperties === null) {
+				this.subKernelProperties = {};
+				this.subKernelNames = [];
 			}
-			return result;
-		}
-	}, {
-		key: 'getAstString',
-		value: function getAstString(source, ast) {
-			var lines = Array.isArray(source) ? source : source.split(/\r?\n/g);
-			var start = ast.loc.start;
-			var end = ast.loc.end;
-			var result = [];
-			result.push(lines[start.line - 1].slice(start.column));
-			for (var i = start.line; i < end.line - 1; i++) {
-				result.push(lines[i]);
+			if (this.subKernelProperties.hasOwnProperty(property)) {
+				throw new Error('cannot add sub kernel ' + property + ', already defined');
 			}
-			result.push(lines[end.line - 1].slice(0, end.column));
-			return result.join('\n');
+			this.subKernelProperties[property] = fnString;
+			this.subKernelNames.push(utils.getFunctionNameFromString(fnString));
+			return this;
 		}
 	}, {
-		key: 'allPropertiesOf',
-		value: function allPropertiesOf(obj) {
-			var props = [];
-
-			do {
-				props.push.apply(props, Object.getOwnPropertyNames(obj));
-			} while (obj = Object.getPrototypeOf(obj));
-
-			return props;
+		key: 'addNativeFunction',
+		value: function addNativeFunction(name, source) {
+			this.functionBuilder.addNativeFunction(name, source);
 		}
 	}]);
 
-	return Utils;
-}(UtilsCore);
-
-// This ensure static methods are "inherited"
-// See: https://stackoverflow.com/questions/5441508/how-to-inherit-static-methods-from-base-class-in-javascript
-
-
-Object.assign(Utils, UtilsCore);
-
-module.exports = Utils;
-},{"../index":75,"./input":71,"./texture":72,"./utils-core":73}],75:[function(require,module,exports){
+	return BaseKernel;
+}();
+},{"../core/utils":75}],59:[function(require,module,exports){
 'use strict';
 
-var GPU = require('./core/gpu');
-var alias = require('./core/alias');
-var utils = require('./core/utils');
-var Input = require('./core/input');
-var Texture = require('./core/texture');
-
-var CPUFunctionBuilder = require('./backend/cpu/function-builder');
-var CPUFunctionNode = require('./backend/cpu/function-node');
-var CPUKernel = require('./backend/cpu/kernel');
-var CPURunner = require('./backend/cpu/runner');
-
-var WebGLFunctionBuilder = require('./backend/web-gl/function-builder');
-var WebGLFunctionNode = require('./backend/web-gl/function-node');
-var WebGLKernel = require('./backend/web-gl/kernel');
-var WebGLRunner = require('./backend/web-gl/runner');
-
-GPU.alias = alias;
-GPU.utils = utils;
-GPU.Texture = Texture;
-GPU.Input = Input;
-GPU.input = function (value, size) {
-	return new Input(value, size);
-};
-
-GPU.CPUFunctionBuilder = CPUFunctionBuilder;
-GPU.CPUFunctionNode = CPUFunctionNode;
-GPU.CPUKernel = CPUKernel;
-GPU.CPURunner = CPURunner;
-
-GPU.WebGLFunctionBuilder = WebGLFunctionBuilder;
-GPU.WebGLFunctionNode = WebGLFunctionNode;
-GPU.WebGLKernel = WebGLKernel;
-GPU.WebGLRunner = WebGLRunner;
-
-if (typeof module !== 'undefined') {
-	module.exports = GPU;
-}
-if (typeof window !== 'undefined') {
-	window.GPU = GPU;
-}
-},{"./backend/cpu/function-builder":50,"./backend/cpu/function-node":51,"./backend/cpu/kernel":53,"./backend/cpu/runner":54,"./backend/web-gl/function-builder":60,"./backend/web-gl/function-node":61,"./backend/web-gl/kernel":63,"./backend/web-gl/runner":64,"./core/alias":68,"./core/gpu":70,"./core/input":71,"./core/texture":72,"./core/utils":74}],76:[function(require,module,exports){
-(function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-	typeof define === 'function' && define.amd ? define(['exports'], factory) :
-	(factory((global.acorn = {})));
-}(this, (function (exports) { 'use strict';
-
-// Reserved word lists for various dialects of the language
+var utils = require('../core/utils');
 
-var reservedWords = {
-  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
-  5: "class enum extends super const export import",
-  6: "enum",
-  strict: "implements interface let package private protected public static yield",
-  strictBind: "eval arguments"
-};
+module.exports = function kernelRunShortcut(kernel) {
+	var shortcut = function shortcut() {
+		return kernel.run.apply(kernel, arguments);
+	};
 
-// And the keywords
+	utils.allPropertiesOf(kernel).forEach(function (key) {
+		if (key[0] === '_' && key[1] === '_') return;
+		if (typeof kernel[key] === 'function') {
+			if (key.substring(0, 3) === 'add' || key.substring(0, 3) === 'set') {
+				shortcut[key] = function () {
+					kernel[key].apply(kernel, arguments);
+					return shortcut;
+				};
+			} else {
+				shortcut[key] = kernel[key].bind(kernel);
+			}
+		} else {
+			shortcut.__defineGetter__(key, function () {
+				return kernel[key];
+			});
+			shortcut.__defineSetter__(key, function (value) {
+				kernel[key] = value;
+			});
+		}
+	});
 
-var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+	shortcut.kernel = kernel;
 
-var keywords = {
-  5: ecma5AndLessKeywords,
-  6: ecma5AndLessKeywords + " const class extends export import super"
+	return shortcut;
 };
+},{"../core/utils":75}],60:[function(require,module,exports){
+'use strict';
 
-var keywordRelationalOperator = /^in(stanceof)?$/;
-
-// ## Character categories
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-// Big ugly regular expressions that match characters in the
-// whitespace, identifier, and identifier-start categories. These
-// are only applied when a character is found to actually have a
-// code point above 128.
-// Generated by `bin/generate-identifier-regex.js`.
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fd5\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ae\ua7b0-\ua7b7\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab65\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d4-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d01-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf8\u1cf9\u1dc0-\u1df5\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+var utils = require('../core/utils');
+var kernelRunShortcut = require('./kernel-run-shortcut');
 
-var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+module.exports = function () {
 
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+	/**
+  * @constructor BaseRunner
+  *
+  * @desc Represents the 'private/protected' namespace of the GPU class
+  *
+  * <p>I know @private makes more sense, but since the documentation engine state is undetirmined.
+  * (See https://github.com/gpujs/gpu.js/issues/19 regarding documentation engine issue)
+  * File isolation is currently the best way to go. </p>
+  *
+  * *base.js* internal functions namespace <br>
+  * *gpu.js* PUBLIC function namespace <br>
+  *
+  * @prop {Object} settings - Settings object used to set Dimensions, etc.
+  * @prop {String} kernel - Current kernel instance
+  * @prop {Object} canvas - Canvas instance attached to the kernel
+  * @prop {Object} webGl - WebGl instance attached to the kernel
+  * @prop {Function} fn - Kernel function to run
+  * @prop {Object} functionBuilder - FunctionBuilder instance
+  * @prop {String} fnString - Kernel function (as a String)
+  * @prop {String} endianness - endian information like Little-endian, Big-endian.
+  *
+  */
 
-// These are a run-length and offset encoded representation of the
-// >0xffff code points that are a valid part of identifiers. The
-// offset starts at 0x10000, and each pair of numbers represents an
-// offset to the next range, and then a size of the range. They were
-// generated by bin/generate-identifier-regex.js
+	function BaseRunner(functionBuilder, settings) {
+		_classCallCheck(this, BaseRunner);
 
-// eslint-disable-next-line comma-spacing
-var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541];
+		settings = settings || {};
+		this.kernel = settings.kernel;
+		this.canvas = settings.canvas;
+		this.webGl = settings.webGl;
+		this.fn = null;
+		this.functionBuilder = functionBuilder;
+		this.fnString = null;
+		this.endianness = utils.systemEndianness();
+		this.functionBuilder.polyfillStandardFunctions();
+	}
 
-// eslint-disable-next-line comma-spacing
-var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239];
+	/**
+  * @memberOf BaseRunner#
+  * @function
+  * @name textureToArray
+  *
+  * @desc Converts the provided Texture instance to a JavaScript Array
+  *
+  * @param {Object} texture - Texture Object
+  *
+  */
 
-// This has a complexity linear to the value of the code. The
-// assumption is that looking up astral identifier characters is
-// rare.
-function isInAstralSet(code, set) {
-  var pos = 0x10000;
-  for (var i = 0; i < set.length; i += 2) {
-    pos += set[i];
-    if (pos > code) { return false }
-    pos += set[i + 1];
-    if (pos >= code) { return true }
-  }
-}
 
-// Test whether a given character code starts an identifier.
+	_createClass(BaseRunner, [{
+		key: 'textureToArray',
+		value: function textureToArray(texture) {
+			var copy = this.createKernel(function (x) {
+				return x[this.thread.z][this.thread.y][this.thread.x];
+			});
 
-function isIdentifierStart(code, astral) {
-  if (code < 65) { return code === 36 }
-  if (code < 91) { return true }
-  if (code < 97) { return code === 95 }
-  if (code < 123) { return true }
-  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
-  if (astral === false) { return false }
-  return isInAstralSet(code, astralIdentifierStartCodes)
-}
+			return copy(texture);
+		}
 
-// Test whether a given character is part of an identifier.
+		/**
+   * @memberOf BaseRunner#
+   * @function
+   *
+   * @name deleteTexture
+   *
+   * @desc Deletes the provided Texture instance
+   *
+   * @param {Object} texture - Texture Object
+   */
 
-function isIdentifierChar(code, astral) {
-  if (code < 48) { return code === 36 }
-  if (code < 58) { return true }
-  if (code < 65) { return false }
-  if (code < 91) { return true }
-  if (code < 97) { return code === 95 }
-  if (code < 123) { return true }
-  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
-  if (astral === false) { return false }
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
-}
+	}, {
+		key: 'deleteTexture',
+		value: function deleteTexture(texture) {
+			this.webGl.deleteTexture(texture.texture);
+		}
 
-// ## Token types
+		/**
+   * @memberOf BaseRunner#
+   * @function
+   * @name buildPromiseKernel
+   *
+   * @desc Get and returns the ASYNCHRONOUS executor, of a class and kernel
+   * This returns a Promise object from an argument set.
+   *
+   * Note that there is no current implementation.
+   *
+   */
 
-// The assignment of fine-grained, information-carrying type objects
-// allows the tokenizer to store the information it has about a
-// token in a way that is very cheap for the parser to look up.
+	}, {
+		key: 'buildPromiseKernel',
+		value: function buildPromiseKernel() {
+			throw new Error('not yet implemented');
+		}
+	}, {
+		key: 'getMode',
+		value: function getMode() {
+			throw new Error('"mode" not implemented on BaseRunner');
+		}
 
-// All token type variables start with an underscore, to make them
-// easy to recognize.
+		/**
+   * @memberOf BaseRunner#
+   * @function
+   *
+   * @name buildKernel
+   *
+   * @desc Get and returns the Synchronous executor, of a class and kernel
+   * Which returns the result directly after passing the arguments.
+   *
+   */
 
-// The `beforeExpr` property is used to disambiguate between regular
-// expressions and divisions. It is set on all token types that can
-// be followed by an expression (thus, a slash after them would be a
-// regular expression).
-//
-// The `startsExpr` property is used to check if the token ends a
-// `yield` expression. It is set on all token types that either can
-// directly start an expression (like a quotation mark) or can
-// continue an expression (like the body of a string).
-//
-// `isLoop` marks a keyword as starting a loop, which is important
-// to know when parsing a label, in order to allow or disallow
-// continue jumps to that label.
+	}, {
+		key: 'buildKernel',
+		value: function buildKernel(fn, settings) {
+			settings = Object.assign({}, settings || {});
+			var fnString = fn.toString();
+			if (!settings.functionBuilder) {
+				settings.functionBuilder = this.functionBuilder;
+			}
 
-var TokenType = function TokenType(label, conf) {
-  if ( conf === void 0 ) conf = {};
+			if (!settings.canvas) {
+				settings.canvas = this.canvas;
+			}
 
-  this.label = label;
-  this.keyword = conf.keyword;
-  this.beforeExpr = !!conf.beforeExpr;
-  this.startsExpr = !!conf.startsExpr;
-  this.isLoop = !!conf.isLoop;
-  this.isAssign = !!conf.isAssign;
-  this.prefix = !!conf.prefix;
-  this.postfix = !!conf.postfix;
-  this.binop = conf.binop || null;
-  this.updateContext = null;
-};
+			if (!settings.webGl) {
+				settings.webGl = this.webgl;
+			}
 
-function binop(name, prec) {
-  return new TokenType(name, {beforeExpr: true, binop: prec})
-}
-var beforeExpr = {beforeExpr: true};
-var startsExpr = {startsExpr: true};
+			return kernelRunShortcut(new this.Kernel(fnString, settings));
+		}
+	}]);
 
-// Map keyword names to token types.
+	return BaseRunner;
+}();
+},{"../core/utils":75,"./kernel-run-shortcut":59}],61:[function(require,module,exports){
+'use strict';
 
-var keywords$1 = {};
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-// Succinct definitions of keyword token types
-function kw(name, options) {
-  if ( options === void 0 ) options = {};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  options.keyword = name;
-  return keywords$1[name] = new TokenType(name, options)
-}
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-var types = {
-  num: new TokenType("num", startsExpr),
-  regexp: new TokenType("regexp", startsExpr),
-  string: new TokenType("string", startsExpr),
-  name: new TokenType("name", startsExpr),
-  eof: new TokenType("eof"),
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-  // Punctuation token types.
-  bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
-  bracketR: new TokenType("]"),
-  braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
-  braceR: new TokenType("}"),
-  parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
-  parenR: new TokenType(")"),
-  comma: new TokenType(",", beforeExpr),
-  semi: new TokenType(";", beforeExpr),
-  colon: new TokenType(":", beforeExpr),
-  dot: new TokenType("."),
-  question: new TokenType("?", beforeExpr),
-  arrow: new TokenType("=>", beforeExpr),
-  template: new TokenType("template"),
-  invalidTemplate: new TokenType("invalidTemplate"),
-  ellipsis: new TokenType("...", beforeExpr),
-  backQuote: new TokenType("`", startsExpr),
-  dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
+var FunctionBuilderBase = require('../function-builder-base');
+var WebGLFunctionNode = require('./function-node');
 
-  // Operators. These carry several kinds of properties to help the
-  // parser use them properly (the presence of these properties is
-  // what categorizes them as operators).
-  //
-  // `binop`, when present, specifies that this operator is a binary
-  // operator, and will refer to its precedence.
-  //
-  // `prefix` and `postfix` mark the operator as a prefix or postfix
-  // unary operator.
-  //
-  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
-  // binary operators with a very low precedence, that should result
-  // in AssignmentExpression nodes.
+/**
+ * @class WebGLFunctionBuilder
+ *
+ * @extends FunctionBuilderBase
+ *
+ * @desc Builds webGl functions (shaders) from JavaScript function Strings
+ *
+ */
+module.exports = function (_FunctionBuilderBase) {
+	_inherits(WebGLFunctionBuilder, _FunctionBuilderBase);
 
-  eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
-  assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
-  incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
-  prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
-  logicalOR: binop("||", 1),
-  logicalAND: binop("&&", 2),
-  bitwiseOR: binop("|", 3),
-  bitwiseXOR: binop("^", 4),
-  bitwiseAND: binop("&", 5),
-  equality: binop("==/!=/===/!==", 6),
-  relational: binop("</>/<=/>=", 7),
-  bitShift: binop("<</>>/>>>", 8),
-  plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
-  modulo: binop("%", 10),
-  star: binop("*", 10),
-  slash: binop("/", 10),
-  starstar: new TokenType("**", {beforeExpr: true}),
+	function WebGLFunctionBuilder() {
+		_classCallCheck(this, WebGLFunctionBuilder);
 
-  // Keyword token types.
-  _break: kw("break"),
-  _case: kw("case", beforeExpr),
-  _catch: kw("catch"),
-  _continue: kw("continue"),
-  _debugger: kw("debugger"),
-  _default: kw("default", beforeExpr),
-  _do: kw("do", {isLoop: true, beforeExpr: true}),
-  _else: kw("else", beforeExpr),
-  _finally: kw("finally"),
-  _for: kw("for", {isLoop: true}),
-  _function: kw("function", startsExpr),
-  _if: kw("if"),
-  _return: kw("return", beforeExpr),
-  _switch: kw("switch"),
-  _throw: kw("throw", beforeExpr),
-  _try: kw("try"),
-  _var: kw("var"),
-  _const: kw("const"),
-  _while: kw("while", {isLoop: true}),
-  _with: kw("with"),
-  _new: kw("new", {beforeExpr: true, startsExpr: true}),
-  _this: kw("this", startsExpr),
-  _super: kw("super", startsExpr),
-  _class: kw("class", startsExpr),
-  _extends: kw("extends", beforeExpr),
-  _export: kw("export"),
-  _import: kw("import"),
-  _null: kw("null", startsExpr),
-  _true: kw("true", startsExpr),
-  _false: kw("false", startsExpr),
-  _in: kw("in", {beforeExpr: true, binop: 7}),
-  _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
-  _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
-  _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
-  _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
-};
+		var _this = _possibleConstructorReturn(this, (WebGLFunctionBuilder.__proto__ || Object.getPrototypeOf(WebGLFunctionBuilder)).call(this));
 
-// Matches a whole line break (where CRLF is considered a single
-// line break). Used to count lines.
+		_this.Node = WebGLFunctionNode;
+		return _this;
+	}
 
-var lineBreak = /\r\n?|\n|\u2028|\u2029/;
-var lineBreakG = new RegExp(lineBreak.source, "g");
+	//---------------------------------------------------------
+	//
+	//  Polyfill stuff
+	//
+	//---------------------------------------------------------
 
-function isNewLine(code) {
-  return code === 10 || code === 13 || code === 0x2028 || code === 0x2029
-}
+	// Round function used in polyfill
 
-var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
 
-var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+	_createClass(WebGLFunctionBuilder, [{
+		key: 'polyfillStandardFunctions',
 
-var ref = Object.prototype;
-var hasOwnProperty = ref.hasOwnProperty;
-var toString = ref.toString;
 
-// Checks if an object has a property.
+		/**
+   * @memberOf FunctionBuilderBase#
+   * @function
+   * @name polyfillStandardFunctions
+   *
+   * @desc Polyfill in the missing Math functions (round)
+   *
+   */
+		value: function polyfillStandardFunctions() {
+			this.addFunction('round', _round);
+		}
+	}], [{
+		key: 'round',
+		value: function round(a) {
+			return _round(a);
+		}
+	}]);
 
-function has(obj, propName) {
-  return hasOwnProperty.call(obj, propName)
+	return WebGLFunctionBuilder;
+}(FunctionBuilderBase);
+
+function _round(a) {
+	return Math.floor(a + 0.5);
 }
+},{"../function-builder-base":56,"./function-node":62}],62:[function(require,module,exports){
+'use strict';
 
-var isArray = Array.isArray || (function (obj) { return (
-  toString.call(obj) === "[object Array]"
-); });
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-// These are used when `options.locations` is on, for the
-// `startLoc` and `endLoc` properties.
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var Position = function Position(line, col) {
-  this.line = line;
-  this.column = col;
-};
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-Position.prototype.offset = function offset (n) {
-  return new Position(this.line, this.column + n)
-};
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-var SourceLocation = function SourceLocation(p, start, end) {
-  this.start = start;
-  this.end = end;
-  if (p.sourceFile !== null) { this.source = p.sourceFile; }
-};
+var FunctionNodeBase = require('../function-node-base');
+var utils = require('../../core/utils');
+// Closure capture for the ast function, prevent collision with existing AST functions
+// The prefixes to use
+var jsMathPrefix = 'Math.';
+var localPrefix = 'this.';
+var constantsPrefix = 'this.constants.';
 
-// The `getLineInfo` function is mostly useful when the
-// `locations` option is off (for performance reasons) and you
-// want to find the line/column position for a given character
-// offset. `input` should be the code string that the offset refers
-// into.
+var DECODE32_ENCODE32 = /decode32\(\s+encode32\(/g;
+var ENCODE32_DECODE32 = /encode32\(\s+decode32\(/g;
 
-function getLineInfo(input, offset) {
-  for (var line = 1, cur = 0;;) {
-    lineBreakG.lastIndex = cur;
-    var match = lineBreakG.exec(input);
-    if (match && match.index < offset) {
-      ++line;
-      cur = match.index + match[0].length;
-    } else {
-      return new Position(line, offset - cur)
-    }
-  }
-}
+/** 
+ * @class WebGLFunctionNode
+ *
+ * @desc [INTERNAL] Takes in a function node, and does all the AST voodoo required to generate its respective webGL code.
+ *
+ * @extends FunctionNodeBase
+ *
+ * @param {functionNode} inNode - The function node object
+ *
+ * @returns the converted webGL function string
+ *
+ */
+module.exports = function (_FunctionNodeBase) {
+	_inherits(WebGLFunctionNode, _FunctionNodeBase);
 
-// A second optional argument can be given to further configure
-// the parser process. These options are recognized:
+	function WebGLFunctionNode() {
+		_classCallCheck(this, WebGLFunctionNode);
 
-var defaultOptions = {
-  // `ecmaVersion` indicates the ECMAScript version to parse. Must
-  // be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support
-  // for strict mode, the set of reserved words, and support for
-  // new syntax features. The default is 7.
-  ecmaVersion: 7,
-  // `sourceType` indicates the mode the code should be parsed in.
-  // Can be either `"script"` or `"module"`. This influences global
-  // strict mode and parsing of `import` and `export` declarations.
-  sourceType: "script",
-  // `onInsertedSemicolon` can be a callback that will be called
-  // when a semicolon is automatically inserted. It will be passed
-  // th position of the comma as an offset, and if `locations` is
-  // enabled, it is given the location as a `{line, column}` object
-  // as second argument.
-  onInsertedSemicolon: null,
-  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
-  // trailing commas.
-  onTrailingComma: null,
-  // By default, reserved words are only enforced if ecmaVersion >= 5.
-  // Set `allowReserved` to a boolean value to explicitly turn this on
-  // an off. When this option has the value "never", reserved words
-  // and keywords can also not be used as property names.
-  allowReserved: null,
-  // When enabled, a return at the top level is not considered an
-  // error.
-  allowReturnOutsideFunction: false,
-  // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
-  allowImportExportEverywhere: false,
-  // When enabled, hashbang directive in the beginning of file
-  // is allowed and treated as a line comment.
-  allowHashBang: false,
-  // When `locations` is on, `loc` properties holding objects with
-  // `start` and `end` properties in `{line, column}` form (with
-  // line being 1-based and column 0-based) will be attached to the
-  // nodes.
-  locations: false,
-  // A function can be passed as `onToken` option, which will
-  // cause Acorn to call that function with object in the same
-  // format as tokens returned from `tokenizer().getToken()`. Note
-  // that you are not allowed to call the parser from the
-  // callback—that will corrupt its internal state.
-  onToken: null,
-  // A function can be passed as `onComment` option, which will
-  // cause Acorn to call that function with `(block, text, start,
-  // end)` parameters whenever a comment is skipped. `block` is a
-  // boolean indicating whether this is a block (`/* */`) comment,
-  // `text` is the content of the comment, and `start` and `end` are
-  // character offsets that denote the start and end of the comment.
-  // When the `locations` option is on, two more parameters are
-  // passed, the full `{line, column}` locations of the start and
-  // end of the comments. Note that you are not allowed to call the
-  // parser from the callback—that will corrupt its internal state.
-  onComment: null,
-  // Nodes have their start and end characters offsets recorded in
-  // `start` and `end` properties (directly on the node, rather than
-  // the `loc` object, which holds line/column data. To also add a
-  // [semi-standardized][range] `range` property holding a `[start,
-  // end]` array with the same numbers, set the `ranges` option to
-  // `true`.
-  //
-  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-  ranges: false,
-  // It is possible to parse multiple files into a single AST by
-  // passing the tree produced by parsing the first file as
-  // `program` option in subsequent parses. This will add the
-  // toplevel forms of the parsed file to the `Program` (top) node
-  // of an existing parse tree.
-  program: null,
-  // When `locations` is on, you can pass this to record the source
-  // file in every node's `loc` object.
-  sourceFile: null,
-  // This value, if given, is stored in every node, whether
-  // `locations` is on or off.
-  directSourceFile: null,
-  // When enabled, parenthesized expressions are represented by
-  // (non-standard) ParenthesizedExpression nodes
-  preserveParens: false,
-  plugins: {}
-};
+		return _possibleConstructorReturn(this, (WebGLFunctionNode.__proto__ || Object.getPrototypeOf(WebGLFunctionNode)).apply(this, arguments));
+	}
 
-// Interpret and default an options object
+	_createClass(WebGLFunctionNode, [{
+		key: 'generate',
+		value: function generate() {
+			if (this.debug) {
+				console.log(this);
+			}
+			if (this.prototypeOnly) {
+				return WebGLFunctionNode.astFunctionPrototype(this.getJsAST(), [], this).join('').trim();
+			} else {
+				this.functionStringArray = this.astGeneric(this.getJsAST(), [], this);
+			}
+			this.functionString = webGlRegexOptimize(this.functionStringArray.join('').trim());
+			return this.functionString;
+		}
 
-function getOptions(opts) {
-  var options = {};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astGeneric
+   *
+   * @desc Parses the abstract syntax tree for generically to its respective function
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the parsed webgl string array
+   */
 
-  for (var opt in defaultOptions)
-    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
+	}, {
+		key: 'astGeneric',
+		value: function astGeneric(ast, retArr, funcParam) {
+			if (ast === null) {
+				throw this.astErrorOutput('NULL ast', ast, funcParam);
+			} else {
+				if (Array.isArray(ast)) {
+					for (var i = 0; i < ast.length; i++) {
+						this.astGeneric(ast[i], retArr, funcParam);
+					}
+					return retArr;
+				}
 
-  if (options.ecmaVersion >= 2015)
-    { options.ecmaVersion -= 2009; }
+				switch (ast.type) {
+					case 'FunctionDeclaration':
+						return this.astFunctionDeclaration(ast, retArr, funcParam);
+					case 'FunctionExpression':
+						return this.astFunctionExpression(ast, retArr, funcParam);
+					case 'ReturnStatement':
+						return this.astReturnStatement(ast, retArr, funcParam);
+					case 'Literal':
+						return this.astLiteral(ast, retArr, funcParam);
+					case 'BinaryExpression':
+						return this.astBinaryExpression(ast, retArr, funcParam);
+					case 'Identifier':
+						return this.astIdentifierExpression(ast, retArr, funcParam);
+					case 'AssignmentExpression':
+						return this.astAssignmentExpression(ast, retArr, funcParam);
+					case 'ExpressionStatement':
+						return this.astExpressionStatement(ast, retArr, funcParam);
+					case 'EmptyStatement':
+						return this.astEmptyStatement(ast, retArr, funcParam);
+					case 'BlockStatement':
+						return this.astBlockStatement(ast, retArr, funcParam);
+					case 'IfStatement':
+						return this.astIfStatement(ast, retArr, funcParam);
+					case 'BreakStatement':
+						return this.astBreakStatement(ast, retArr, funcParam);
+					case 'ContinueStatement':
+						return this.astContinueStatement(ast, retArr, funcParam);
+					case 'ForStatement':
+						return this.astForStatement(ast, retArr, funcParam);
+					case 'WhileStatement':
+						return this.astWhileStatement(ast, retArr, funcParam);
+					case 'VariableDeclaration':
+						return this.astVariableDeclaration(ast, retArr, funcParam);
+					case 'VariableDeclarator':
+						return this.astVariableDeclarator(ast, retArr, funcParam);
+					case 'ThisExpression':
+						return this.astThisExpression(ast, retArr, funcParam);
+					case 'SequenceExpression':
+						return this.astSequenceExpression(ast, retArr, funcParam);
+					case 'UnaryExpression':
+						return this.astUnaryExpression(ast, retArr, funcParam);
+					case 'UpdateExpression':
+						return this.astUpdateExpression(ast, retArr, funcParam);
+					case 'LogicalExpression':
+						return this.astLogicalExpression(ast, retArr, funcParam);
+					case 'MemberExpression':
+						return this.astMemberExpression(ast, retArr, funcParam);
+					case 'CallExpression':
+						return this.astCallExpression(ast, retArr, funcParam);
+					case 'ArrayExpression':
+						return this.astArrayExpression(ast, retArr, funcParam);
+					case 'DebuggerStatement':
+						return this.astDebuggerStatement(ast, retArr, funcParam);
+				}
 
-  if (options.allowReserved == null)
-    { options.allowReserved = options.ecmaVersion < 5; }
+				throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast, funcParam);
+			}
+		}
+
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astFunctionDeclaration
+   *
+   * @desc Parses the abstract syntax tree for to its *named function declaration*
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  if (isArray(options.onToken)) {
-    var tokens = options.onToken;
-    options.onToken = function (token) { return tokens.push(token); };
-  }
-  if (isArray(options.onComment))
-    { options.onComment = pushComment(options, options.onComment); }
+	}, {
+		key: 'astFunctionDeclaration',
+		value: function astFunctionDeclaration(ast, retArr, funcParam) {
+			if (this.addFunction) {
+				this.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
+			}
+			return retArr;
+		}
 
-  return options
-}
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astFunctionPrototype
+   * @static
+   *
+   * @desc Parses the abstract syntax tree for to its *named function prototype*
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-function pushComment(options, array) {
-  return function(block, text, start, end, startLoc, endLoc) {
-    var comment = {
-      type: block ? "Block" : "Line",
-      value: text,
-      start: start,
-      end: end
-    };
-    if (options.locations)
-      { comment.loc = new SourceLocation(this, startLoc, endLoc); }
-    if (options.ranges)
-      { comment.range = [start, end]; }
-    array.push(comment);
-  }
-}
+	}, {
+		key: 'astFunctionExpression',
 
-// Registered plugins
-var plugins = {};
 
-function keywordRegexp(words) {
-  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
-}
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astFunctionExpression
+   *
+   * @desc Parses the abstract syntax tree for to its *named function*
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
+		value: function astFunctionExpression(ast, retArr, funcParam) {
 
-var Parser = function Parser(options, input, startPos) {
-  this.options = options = getOptions(options);
-  this.sourceFile = options.sourceFile;
-  this.keywords = keywordRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5]);
-  var reserved = "";
-  if (!options.allowReserved) {
-    for (var v = options.ecmaVersion;; v--)
-      { if (reserved = reservedWords[v]) { break } }
-    if (options.sourceType == "module") { reserved += " await"; }
-  }
-  this.reservedWords = keywordRegexp(reserved);
-  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
-  this.reservedWordsStrict = keywordRegexp(reservedStrict);
-  this.reservedWordsStrictBind = keywordRegexp(reservedStrict + " " + reservedWords.strictBind);
-  this.input = String(input);
+			// Setup function return type and name
+			if (funcParam.isRootKernel) {
+				retArr.push('void');
+				funcParam.kernalAst = ast;
+			} else {
+				retArr.push(funcParam.returnType);
+			}
+			retArr.push(' ');
+			retArr.push(funcParam.functionName);
+			retArr.push('(');
 
-  // Used to signal to callers of `readWord1` whether the word
-  // contained any escape sequences. This is needed because words with
-  // escape sequences must not be interpreted as keywords.
-  this.containsEsc = false;
+			if (!funcParam.isRootKernel) {
+				// Arguments handling
+				for (var i = 0; i < funcParam.paramNames.length; ++i) {
+					var paramName = funcParam.paramNames[i];
 
-  // Load plugins
-  this.loadPlugins(options.plugins);
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					var type = funcParam.getParamType(paramName);
+					switch (type) {
+						case 'Texture':
+						case 'Input':
+						case 'Array':
+							retArr.push('sampler2D');
+							break;
+						default:
+							retArr.push('float');
+					}
 
-  // Set up token state
+					retArr.push(' ');
+					retArr.push('user_');
+					retArr.push(paramName);
+				}
+			}
 
-  // The current position of the tokenizer in the input.
-  if (startPos) {
-    this.pos = startPos;
-    this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
-    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
-  } else {
-    this.pos = this.lineStart = 0;
-    this.curLine = 1;
-  }
+			// Function opening
+			retArr.push(') {\n');
 
-  // Properties of the current token:
-  // Its type
-  this.type = types.eof;
-  // For tokens that include more information than their type, the value
-  this.value = null;
-  // Its start and end offset
-  this.start = this.end = this.pos;
-  // And, if locations are used, the {line, column} object
-  // corresponding to those offsets
-  this.startLoc = this.endLoc = this.curPosition();
+			// Body statement iteration
+			for (var _i = 0; _i < ast.body.body.length; ++_i) {
+				this.astGeneric(ast.body.body[_i], retArr, funcParam);
+				retArr.push('\n');
+			}
 
-  // Position information for the previous token
-  this.lastTokEndLoc = this.lastTokStartLoc = null;
-  this.lastTokStart = this.lastTokEnd = this.pos;
+			// Function closing
+			retArr.push('}\n');
+			return retArr;
+		}
 
-  // The context stack is used to superficially track syntactic
-  // context to predict whether a regular expression is allowed in a
-  // given position.
-  this.context = this.initialContext();
-  this.exprAllowed = true;
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astReturnStatement
+   *
+   * @desc Parses the abstract syntax tree for to *return* statement
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Object} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  // Figure out if it's a module code.
-  this.inModule = options.sourceType === "module";
-  this.strict = this.inModule || this.strictDirective(this.pos);
+	}, {
+		key: 'astReturnStatement',
+		value: function astReturnStatement(ast, retArr, funcParam) {
+			if (funcParam.isRootKernel) {
+				retArr.push('kernelResult = ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+				retArr.push('return;');
+			} else if (funcParam.isSubKernel) {
+				retArr.push(funcParam.functionName + 'Result = ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+				retArr.push('return ' + funcParam.functionName + 'Result;');
+			} else {
+				retArr.push('return ');
+				this.astGeneric(ast.argument, retArr, funcParam);
+				retArr.push(';');
+			}
 
-  // Used to signify the start of a potential arrow function
-  this.potentialArrowAt = -1;
+			//throw this.astErrorOutput(
+			//	'Non main function return, is not supported : '+funcParam.currentFunctionNamespace,
+			//	ast, funcParam
+			//);
 
-  // Flags to track whether we are in a function, a generator, an async function.
-  this.inFunction = this.inGenerator = this.inAsync = false;
-  // Positions to delayed-check that yield/await does not exist in default parameters.
-  this.yieldPos = this.awaitPos = 0;
-  // Labels in scope.
-  this.labels = [];
+			return retArr;
+		}
 
-  // If enabled, skip leading hashbang line.
-  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
-    { this.skipLineComment(2); }
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astLiteral
+   *
+   * @desc Parses the abstract syntax tree for *literal value*
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  // Scope tracking for duplicate variable names (see scope.js)
-  this.scopeStack = [];
-  this.enterFunctionScope();
-};
+	}, {
+		key: 'astLiteral',
+		value: function astLiteral(ast, retArr, funcParam) {
 
-// DEPRECATED Kept for backwards compatibility until 3.0 in case a plugin uses them
-Parser.prototype.isKeyword = function isKeyword (word) { return this.keywords.test(word) };
-Parser.prototype.isReservedWord = function isReservedWord (word) { return this.reservedWords.test(word) };
+			// Reject non numeric literals
+			if (isNaN(ast.value)) {
+				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast, funcParam);
+			}
 
-Parser.prototype.extend = function extend (name, f) {
-  this[name] = f(this[name]);
-};
+			// Push the literal value as a float/int
+			retArr.push(ast.value);
 
-Parser.prototype.loadPlugins = function loadPlugins (pluginConfigs) {
-    var this$1 = this;
+			// If it was an int, node made a float
+			if (Number.isInteger(ast.value)) {
+				retArr.push('.0');
+			}
 
-  for (var name in pluginConfigs) {
-    var plugin = plugins[name];
-    if (!plugin) { throw new Error("Plugin '" + name + "' not found") }
-    plugin(this$1, pluginConfigs[name]);
-  }
-};
+			return retArr;
+		}
 
-Parser.prototype.parse = function parse () {
-  var node = this.options.program || this.startNode();
-  this.nextToken();
-  return this.parseTopLevel(node)
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astBinaryExpression
+   *
+   * @desc Parses the abstract syntax tree for *binary* expression
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-var pp = Parser.prototype;
+	}, {
+		key: 'astBinaryExpression',
+		value: function astBinaryExpression(ast, retArr, funcParam) {
+			retArr.push('(');
 
-// ## Parser utilities
+			if (ast.operator === '%') {
+				retArr.push('mod(');
+				this.astGeneric(ast.left, retArr, funcParam);
+				retArr.push(',');
+				this.astGeneric(ast.right, retArr, funcParam);
+				retArr.push(')');
+			} else if (ast.operator === '===') {
+				this.astGeneric(ast.left, retArr, funcParam);
+				retArr.push('==');
+				this.astGeneric(ast.right, retArr, funcParam);
+			} else if (ast.operator === '!==') {
+				this.astGeneric(ast.left, retArr, funcParam);
+				retArr.push('!=');
+				this.astGeneric(ast.right, retArr, funcParam);
+			} else {
+				this.astGeneric(ast.left, retArr, funcParam);
+				retArr.push(ast.operator);
+				this.astGeneric(ast.right, retArr, funcParam);
+			}
 
-var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;
-pp.strictDirective = function(start) {
-  var this$1 = this;
+			retArr.push(')');
 
-  for (;;) {
-    skipWhiteSpace.lastIndex = start;
-    start += skipWhiteSpace.exec(this$1.input)[0].length;
-    var match = literal.exec(this$1.input.slice(start));
-    if (!match) { return false }
-    if ((match[1] || match[2]) == "use strict") { return true }
-    start += match[0].length;
-  }
-};
+			return retArr;
+		}
 
-// Predicate that tests whether the next token is of the given
-// type, and if yes, consumes it as a side effect.
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astIdentifierExpression
+   *
+   * @desc Parses the abstract syntax tree for *identifier* expression
+   *
+   * @param {Object} idtNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp.eat = function(type) {
-  if (this.type === type) {
-    this.next();
-    return true
-  } else {
-    return false
-  }
-};
+	}, {
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(idtNode, retArr, funcParam) {
+			if (idtNode.type !== 'Identifier') {
+				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode, funcParam);
+			}
 
-// Tests whether parsed token is a contextual keyword.
+			switch (idtNode.name) {
+				case 'gpu_threadX':
+					retArr.push('threadId.x');
+					break;
+				case 'gpu_threadY':
+					retArr.push('threadId.y');
+					break;
+				case 'gpu_threadZ':
+					retArr.push('threadId.z');
+					break;
+				case 'gpu_outputX':
+					retArr.push('uOutputDim.x');
+					break;
+				case 'gpu_outputY':
+					retArr.push('uOutputDim.y');
+					break;
+				case 'gpu_outputZ':
+					retArr.push('uOutputDim.z');
+					break;
+				default:
+					if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
+						retArr.push('constants_' + idtNode.name);
+					} else {
+						var userParamName = funcParam.getUserParamName(idtNode.name);
+						if (userParamName !== null) {
+							retArr.push('user_' + userParamName);
+						} else {
+							retArr.push('user_' + idtNode.name);
+						}
+					}
+			}
 
-pp.isContextual = function(name) {
-  return this.type === types.name && this.value === name && !this.containsEsc
-};
+			return retArr;
+		}
 
-// Consumes contextual keyword if possible.
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astForStatement
+   *
+   * @desc Parses the abstract syntax tree forfor *for-loop* expression
+   *
+   * @param {Object} forNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the parsed webgl string
+   */
 
-pp.eatContextual = function(name) {
-  if (!this.isContextual(name)) { return false }
-  this.next();
-  return true
-};
+	}, {
+		key: 'astForStatement',
+		value: function astForStatement(forNode, retArr, funcParam) {
+			if (forNode.type !== 'ForStatement') {
+				throw this.astErrorOutput('Invalid for statment', forNode, funcParam);
+			}
 
-// Asserts that following token is given contextual keyword.
+			if (forNode.test && forNode.test.type === 'BinaryExpression') {
+				if (forNode.test.right.type === 'Identifier' && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {
 
-pp.expectContextual = function(name) {
-  if (!this.eatContextual(name)) { this.unexpected(); }
-};
+					if (!this.loopMaxIterations) {
+						console.warn('Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior.');
+						console.warn('Set loopMaxIterations or use a for loop of fixed length to silence this message.');
+					}
 
-// Test whether a semicolon can be inserted at the current position.
+					retArr.push('for (');
+					this.astGeneric(forNode.init, retArr, funcParam);
+					this.astGeneric(forNode.test.left, retArr, funcParam);
+					retArr.push(forNode.test.operator);
+					retArr.push('LOOP_MAX');
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr, funcParam);
+					retArr.push(')');
 
-pp.canInsertSemicolon = function() {
-  return this.type === types.eof ||
-    this.type === types.braceR ||
-    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
-};
+					retArr.push('{\n');
+					retArr.push('if (');
+					this.astGeneric(forNode.test.left, retArr, funcParam);
+					retArr.push(forNode.test.operator);
+					this.astGeneric(forNode.test.right, retArr, funcParam);
+					retArr.push(') {\n');
+					if (forNode.body.type === 'BlockStatement') {
+						for (var i = 0; i < forNode.body.body.length; i++) {
+							this.astGeneric(forNode.body.body[i], retArr, funcParam);
+						}
+					} else {
+						this.astGeneric(forNode.body, retArr, funcParam);
+					}
+					retArr.push('} else {\n');
+					retArr.push('break;\n');
+					retArr.push('}\n');
+					retArr.push('}\n');
 
-pp.insertSemicolon = function() {
-  if (this.canInsertSemicolon()) {
-    if (this.options.onInsertedSemicolon)
-      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
-    return true
-  }
-};
+					return retArr;
+				} else {
+					var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));
+					var updateArgument = forNode.update.argument;
+					if (!Array.isArray(declarations) || declarations.length < 1) {
+						console.log(this.jsFunctionString);
+						throw new Error('Error: Incompatible for loop declaration');
+					}
 
-// Consume a semicolon, or, failing that, see if we are allowed to
-// pretend that there is a semicolon at this position.
+					if (declarations.length > 1) {
+						var initArgument = null;
+						for (var _i2 = 0; _i2 < declarations.length; _i2++) {
+							var declaration = declarations[_i2];
+							if (declaration.id.name === updateArgument.name) {
+								initArgument = declaration;
+								declarations.splice(_i2, 1);
+							} else {
+								retArr.push('float ');
+								this.astGeneric(declaration, retArr, funcParam);
+								retArr.push(';');
+							}
+						}
 
-pp.semicolon = function() {
-  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
-};
+						retArr.push('for (float ');
+						this.astGeneric(initArgument, retArr, funcParam);
+						retArr.push(';');
+					} else {
+						retArr.push('for (');
+						this.astGeneric(forNode.init, retArr, funcParam);
+					}
 
-pp.afterTrailingComma = function(tokType, notNext) {
-  if (this.type == tokType) {
-    if (this.options.onTrailingComma)
-      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
-    if (!notNext)
-      { this.next(); }
-    return true
-  }
-};
+					this.astGeneric(forNode.test, retArr, funcParam);
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr, funcParam);
+					retArr.push(')');
+					this.astGeneric(forNode.body, retArr, funcParam);
+					return retArr;
+				}
+			}
 
-// Expect a token of a given type. If found, consume it, otherwise,
-// raise an unexpected token error.
+			throw this.astErrorOutput('Invalid for statement', forNode, funcParam);
+		}
 
-pp.expect = function(type) {
-  this.eat(type) || this.unexpected();
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astWhileStatement
+   *
+   * @desc Parses the abstract syntax tree for *while* loop
+   *
+   *
+   * @param {Object} whileNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the parsed webgl string
+   */
 
-// Raise an unexpected token error.
+	}, {
+		key: 'astWhileStatement',
+		value: function astWhileStatement(whileNode, retArr, funcParam) {
+			if (whileNode.type !== 'WhileStatement') {
+				throw this.astErrorOutput('Invalid while statment', whileNode, funcParam);
+			}
 
-pp.unexpected = function(pos) {
-  this.raise(pos != null ? pos : this.start, "Unexpected token");
-};
+			retArr.push('for (float i = 0.0; i < LOOP_MAX; i++) {');
+			retArr.push('if (');
+			this.astGeneric(whileNode.test, retArr, funcParam);
+			retArr.push(') {\n');
+			this.astGeneric(whileNode.body, retArr, funcParam);
+			retArr.push('} else {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
 
-function DestructuringErrors() {
-  this.shorthandAssign =
-  this.trailingComma =
-  this.parenthesizedAssign =
-  this.parenthesizedBind =
-  this.doubleProto =
-    -1;
-}
+			return retArr;
+		}
 
-pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
-  if (!refDestructuringErrors) { return }
-  if (refDestructuringErrors.trailingComma > -1)
-    { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
-  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
-  if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astAssignmentExpression
+   *
+   * @desc Parses the abstract syntax tree for *Assignment* Expression
+   *
+   * @param {Object} assNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
-  if (!refDestructuringErrors) { return false }
-  var shorthandAssign = refDestructuringErrors.shorthandAssign;
-  var doubleProto = refDestructuringErrors.doubleProto;
-  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
-  if (shorthandAssign >= 0)
-    { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
-  if (doubleProto >= 0)
-    { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
-};
+	}, {
+		key: 'astAssignmentExpression',
+		value: function astAssignmentExpression(assNode, retArr, funcParam) {
+			if (assNode.operator === '%=') {
+				this.astGeneric(assNode.left, retArr, funcParam);
+				retArr.push('=');
+				retArr.push('mod(');
+				this.astGeneric(assNode.left, retArr, funcParam);
+				retArr.push(',');
+				this.astGeneric(assNode.right, retArr, funcParam);
+				retArr.push(')');
+			} else {
+				this.astGeneric(assNode.left, retArr, funcParam);
+				retArr.push(assNode.operator);
+				this.astGeneric(assNode.right, retArr, funcParam);
+				return retArr;
+			}
+		}
 
-pp.checkYieldAwaitInDefaultParams = function() {
-  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
-    { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
-  if (this.awaitPos)
-    { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astEmptyStatement
+   *
+   * @desc Parses the abstract syntax tree for an *Empty* Statement
+   *
+   * @param {Object} eNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp.isSimpleAssignTarget = function(expr) {
-  if (expr.type === "ParenthesizedExpression")
-    { return this.isSimpleAssignTarget(expr.expression) }
-  return expr.type === "Identifier" || expr.type === "MemberExpression"
-};
+	}, {
+		key: 'astEmptyStatement',
+		value: function astEmptyStatement(eNode, retArr, funcParam) {
+			//retArr.push(';\n');
+			return retArr;
+		}
 
-var pp$1 = Parser.prototype;
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astBlockStatement
+   *
+   * @desc Parses the abstract syntax tree for *Block* statement
+   *
+   * @param {Object} bnode - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-// ### Statement parsing
+	}, {
+		key: 'astBlockStatement',
+		value: function astBlockStatement(bNode, retArr, funcParam) {
+			retArr.push('{\n');
+			for (var i = 0; i < bNode.body.length; i++) {
+				this.astGeneric(bNode.body[i], retArr, funcParam);
+			}
+			retArr.push('}\n');
+			return retArr;
+		}
 
-// Parse a program. Initializes the parser, reads any number of
-// statements, and wraps them in a Program node.  Optionally takes a
-// `program` argument.  If present, the statements will be appended
-// to its body instead of creating a new node.
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astExpressionStatement
+   *
+   * @desc Parses the abstract syntax tree for *generic expression* statement
+   *
+   * @param {Object} esNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp$1.parseTopLevel = function(node) {
-  var this$1 = this;
+	}, {
+		key: 'astExpressionStatement',
+		value: function astExpressionStatement(esNode, retArr, funcParam) {
+			this.astGeneric(esNode.expression, retArr, funcParam);
+			retArr.push(';\n');
+			return retArr;
+		}
 
-  var exports = {};
-  if (!node.body) { node.body = []; }
-  while (this.type !== types.eof) {
-    var stmt = this$1.parseStatement(true, true, exports);
-    node.body.push(stmt);
-  }
-  this.adaptDirectivePrologue(node.body);
-  this.next();
-  if (this.options.ecmaVersion >= 6) {
-    node.sourceType = this.options.sourceType;
-  }
-  return this.finishNode(node, "Program")
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astVariableDeclaration
+   *
+   * @desc Parses the abstract syntax tree for *Variable Declaration*
+   *
+   * @param {Object} vardecNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-var loopLabel = {kind: "loop"};
-var switchLabel = {kind: "switch"};
+	}, {
+		key: 'astVariableDeclaration',
+		value: function astVariableDeclaration(vardecNode, retArr, funcParam) {
+			retArr.push('float ');
+			for (var i = 0; i < vardecNode.declarations.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
+				}
+				this.astGeneric(vardecNode.declarations[i], retArr, funcParam);
+			}
+			retArr.push(';');
+			return retArr;
+		}
 
-pp$1.isLet = function() {
-  if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
-  skipWhiteSpace.lastIndex = this.pos;
-  var skip = skipWhiteSpace.exec(this.input);
-  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
-  if (nextCh === 91 || nextCh == 123) { return true } // '{' and '['
-  if (isIdentifierStart(nextCh, true)) {
-    var pos = next + 1;
-    while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
-    var ident = this.input.slice(next, pos);
-    if (!keywordRelationalOperator.test(ident)) { return true }
-  }
-  return false
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astVariableDeclarator
+   *
+   * @desc Parses the abstract syntax tree for *Variable Declarator*
+   *
+   * @param {Object} ivardecNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-// check 'async [no LineTerminator here] function'
-// - 'async /*foo*/ function' is OK.
-// - 'async /*\n*/ function' is invalid.
-pp$1.isAsyncFunction = function() {
-  if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
-    { return false }
+	}, {
+		key: 'astVariableDeclarator',
+		value: function astVariableDeclarator(ivardecNode, retArr, funcParam) {
+			this.astGeneric(ivardecNode.id, retArr, funcParam);
+			if (ivardecNode.init !== null) {
+				retArr.push('=');
+				this.astGeneric(ivardecNode.init, retArr, funcParam);
+			}
+			return retArr;
+		}
 
-  skipWhiteSpace.lastIndex = this.pos;
-  var skip = skipWhiteSpace.exec(this.input);
-  var next = this.pos + skip[0].length;
-  return !lineBreak.test(this.input.slice(this.pos, next)) &&
-    this.input.slice(next, next + 8) === "function" &&
-    (next + 8 == this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astIfStatement
+   *
+   * @desc Parses the abstract syntax tree for *If* Statement
+   *
+   * @param {Object} ifNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-// Parse a single statement.
-//
-// If expecting a statement and finding a slash operator, parse a
-// regular expression literal. This is to handle cases like
-// `if (foo) /blah/.exec(foo)`, where looking at the previous token
-// does not help.
+	}, {
+		key: 'astIfStatement',
+		value: function astIfStatement(ifNode, retArr, funcParam) {
+			retArr.push('if (');
+			this.astGeneric(ifNode.test, retArr, funcParam);
+			retArr.push(')');
+			if (ifNode.consequent.type === 'BlockStatement') {
+				this.astGeneric(ifNode.consequent, retArr, funcParam);
+			} else {
+				retArr.push(' {\n');
+				this.astGeneric(ifNode.consequent, retArr, funcParam);
+				retArr.push('\n}\n');
+			}
 
-pp$1.parseStatement = function(declaration, topLevel, exports) {
-  var starttype = this.type, node = this.startNode(), kind;
+			if (ifNode.alternate) {
+				retArr.push('else ');
+				if (ifNode.alternate.type === 'BlockStatement') {
+					this.astGeneric(ifNode.alternate, retArr, funcParam);
+				} else {
+					retArr.push(' {\n');
+					this.astGeneric(ifNode.alternate, retArr, funcParam);
+					retArr.push('\n}\n');
+				}
+			}
+			return retArr;
+		}
 
-  if (this.isLet()) {
-    starttype = types._var;
-    kind = "let";
-  }
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astBreakStatement
+   *
+   * @desc Parses the abstract syntax tree for *Break* Statement
+   *
+   * @param {Object} brNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  // Most types of statements are recognized by the keyword they
-  // start with. Many are trivial to parse, some require a bit of
-  // complexity.
+	}, {
+		key: 'astBreakStatement',
+		value: function astBreakStatement(brNode, retArr, funcParam) {
+			retArr.push('break;\n');
+			return retArr;
+		}
 
-  switch (starttype) {
-  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
-  case types._debugger: return this.parseDebuggerStatement(node)
-  case types._do: return this.parseDoStatement(node)
-  case types._for: return this.parseForStatement(node)
-  case types._function:
-    if (!declaration && this.options.ecmaVersion >= 6) { this.unexpected(); }
-    return this.parseFunctionStatement(node, false)
-  case types._class:
-    if (!declaration) { this.unexpected(); }
-    return this.parseClass(node, true)
-  case types._if: return this.parseIfStatement(node)
-  case types._return: return this.parseReturnStatement(node)
-  case types._switch: return this.parseSwitchStatement(node)
-  case types._throw: return this.parseThrowStatement(node)
-  case types._try: return this.parseTryStatement(node)
-  case types._const: case types._var:
-    kind = kind || this.value;
-    if (!declaration && kind != "var") { this.unexpected(); }
-    return this.parseVarStatement(node, kind)
-  case types._while: return this.parseWhileStatement(node)
-  case types._with: return this.parseWithStatement(node)
-  case types.braceL: return this.parseBlock()
-  case types.semi: return this.parseEmptyStatement(node)
-  case types._export:
-  case types._import:
-    if (!this.options.allowImportExportEverywhere) {
-      if (!topLevel)
-        { this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
-      if (!this.inModule)
-        { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
-    }
-    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astContinueStatement
+   *
+   * @desc Parses the abstract syntax tree for *Continue* Statement
+   *
+   * @param {Object} crNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-    // If the statement does not start with a statement keyword or a
-    // brace, it's an ExpressionStatement or LabeledStatement. We
-    // simply start parsing an expression, and afterwards, if the
-    // next token is a colon and the expression was a simple
-    // Identifier node, we switch to interpreting it as a label.
-  default:
-    if (this.isAsyncFunction()) {
-      if (!declaration) { this.unexpected(); }
-      this.next();
-      return this.parseFunctionStatement(node, true)
-    }
+	}, {
+		key: 'astContinueStatement',
+		value: function astContinueStatement(crNode, retArr, funcParam) {
+			retArr.push('continue;\n');
+			return retArr;
+		}
 
-    var maybeName = this.value, expr = this.parseExpression();
-    if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
-      { return this.parseLabeledStatement(node, maybeName, expr) }
-    else { return this.parseExpressionStatement(node, expr) }
-  }
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astLogicalExpression
+   *
+   * @desc Parses the abstract syntax tree for *Logical* Expression
+   *
+   * @param {Object} logNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp$1.parseBreakContinueStatement = function(node, keyword) {
-  var this$1 = this;
+	}, {
+		key: 'astLogicalExpression',
+		value: function astLogicalExpression(logNode, retArr, funcParam) {
+			retArr.push('(');
+			this.astGeneric(logNode.left, retArr, funcParam);
+			retArr.push(logNode.operator);
+			this.astGeneric(logNode.right, retArr, funcParam);
+			retArr.push(')');
+			return retArr;
+		}
 
-  var isBreak = keyword == "break";
-  this.next();
-  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
-  else if (this.type !== types.name) { this.unexpected(); }
-  else {
-    node.label = this.parseIdent();
-    this.semicolon();
-  }
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astUpdateExpression
+   *
+   * @desc Parses the abstract syntax tree for *Update* Expression
+   *
+   * @param {Object} uNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  // Verify that there is an actual destination to break or
-  // continue to.
-  var i = 0;
-  for (; i < this.labels.length; ++i) {
-    var lab = this$1.labels[i];
-    if (node.label == null || lab.name === node.label.name) {
-      if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
-      if (node.label && isBreak) { break }
-    }
-  }
-  if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
-  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
-};
+	}, {
+		key: 'astUpdateExpression',
+		value: function astUpdateExpression(uNode, retArr, funcParam) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr, funcParam);
+			} else {
+				this.astGeneric(uNode.argument, retArr, funcParam);
+				retArr.push(uNode.operator);
+			}
 
-pp$1.parseDebuggerStatement = function(node) {
-  this.next();
-  this.semicolon();
-  return this.finishNode(node, "DebuggerStatement")
-};
+			return retArr;
+		}
 
-pp$1.parseDoStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  this.expect(types._while);
-  node.test = this.parseParenExpression();
-  if (this.options.ecmaVersion >= 6)
-    { this.eat(types.semi); }
-  else
-    { this.semicolon(); }
-  return this.finishNode(node, "DoWhileStatement")
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astUnaryExpression
+   *
+   * @desc Parses the abstract syntax tree for *Unary* Expression
+   *
+   * @param {Object} uNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
-// loop is non-trivial. Basically, we have to parse the init `var`
-// statement or expression, disallowing the `in` operator (see
-// the second parameter to `parseExpression`), and then check
-// whether the next token is `in` or `of`. When there is no init
-// part (semicolon immediately after the opening parenthesis), it
-// is a regular `for` loop.
+	}, {
+		key: 'astUnaryExpression',
+		value: function astUnaryExpression(uNode, retArr, funcParam) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr, funcParam);
+			} else {
+				this.astGeneric(uNode.argument, retArr, funcParam);
+				retArr.push(uNode.operator);
+			}
 
-pp$1.parseForStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  this.enterLexicalScope();
-  this.expect(types.parenL);
-  if (this.type === types.semi) { return this.parseFor(node, null) }
-  var isLet = this.isLet();
-  if (this.type === types._var || this.type === types._const || isLet) {
-    var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
-    this.next();
-    this.parseVar(init$1, true, kind);
-    this.finishNode(init$1, "VariableDeclaration");
-    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1 &&
-        !(kind !== "var" && init$1.declarations[0].init))
-      { return this.parseForIn(node, init$1) }
-    return this.parseFor(node, init$1)
-  }
-  var refDestructuringErrors = new DestructuringErrors;
-  var init = this.parseExpression(true, refDestructuringErrors);
-  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
-    this.toAssignable(init, false, refDestructuringErrors);
-    this.checkLVal(init);
-    return this.parseForIn(node, init)
-  } else {
-    this.checkExpressionErrors(refDestructuringErrors, true);
-  }
-  return this.parseFor(node, init)
-};
+			return retArr;
+		}
 
-pp$1.parseFunctionStatement = function(node, isAsync) {
-  this.next();
-  return this.parseFunction(node, true, false, isAsync)
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astThisExpression
+   *
+   * @desc Parses the abstract syntax tree for *This* expression
+   *
+   * @param {Object} tNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-pp$1.parseIfStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  // allow function declarations in branches, but only in non-strict mode
-  node.consequent = this.parseStatement(!this.strict && this.type == types._function);
-  node.alternate = this.eat(types._else) ? this.parseStatement(!this.strict && this.type == types._function) : null;
-  return this.finishNode(node, "IfStatement")
-};
+	}, {
+		key: 'astThisExpression',
+		value: function astThisExpression(tNode, retArr, funcParam) {
+			retArr.push('this');
+			return retArr;
+		}
 
-pp$1.parseReturnStatement = function(node) {
-  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
-    { this.raise(this.start, "'return' outside of function"); }
-  this.next();
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astMemberExpression
+   *
+   * @desc Parses the abstract syntax tree for *Member* Expression
+   *
+   * @param {Object} mNode - An ast Node
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  // In `return` (and `break`/`continue`), the keywords with
-  // optional arguments, we eagerly look for a semicolon or the
-  // possibility to insert one.
+	}, {
+		key: 'astMemberExpression',
+		value: function astMemberExpression(mNode, retArr, funcParam) {
+			if (mNode.computed) {
+				if (mNode.object.type === 'Identifier') {
+					// Working logger
+					var reqName = mNode.object.name;
+					var funcName = funcParam.functionName || 'kernel';
+					var assumeNotTexture = false;
 
-  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
-  else { node.argument = this.parseExpression(); this.semicolon(); }
-  return this.finishNode(node, "ReturnStatement")
-};
+					// Possibly an array request - handle it as such
+					if (funcParam.paramNames) {
+						var idx = funcParam.paramNames.indexOf(reqName);
+						if (idx >= 0 && funcParam.paramTypes[idx] === 'float') {
+							assumeNotTexture = true;
+						}
+					}
 
-pp$1.parseSwitchStatement = function(node) {
-  var this$1 = this;
+					if (assumeNotTexture) {
+						// Get from array
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('[int(');
+						this.astGeneric(mNode.property, retArr, funcParam);
+						retArr.push(')]');
+					} else {
+						// Get from texture
+						// This normally refers to the global read only input vars
+						retArr.push('get(');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push(', vec2(');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('Size[0],');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('Size[1]), vec3(');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('Dim[0],');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('Dim[1],');
+						this.astGeneric(mNode.object, retArr, funcParam);
+						retArr.push('Dim[2]');
+						retArr.push('), ');
+						this.astGeneric(mNode.property, retArr, funcParam);
+						retArr.push(')');
+					}
+				} else {
+					this.astGeneric(mNode.object, retArr, funcParam);
+					var last = retArr.pop();
+					retArr.push(',');
+					this.astGeneric(mNode.property, retArr, funcParam);
+					retArr.push(last);
+				}
+			} else {
 
-  this.next();
-  node.discriminant = this.parseParenExpression();
-  node.cases = [];
-  this.expect(types.braceL);
-  this.labels.push(switchLabel);
-  this.enterLexicalScope();
+				// Unroll the member expression
+				var unrolled = this.astMemberExpressionUnroll(mNode);
+				var unrolled_lc = unrolled.toLowerCase();
 
-  // Statements under must be grouped (by label) in SwitchCase
-  // nodes. `cur` is used to keep the node that we are currently
-  // adding statements to.
+				// Its a constant, remove this.constants.
+				if (unrolled.indexOf(constantsPrefix) === 0) {
+					unrolled = 'constants_' + unrolled.slice(constantsPrefix.length);
+				}
 
-  var cur;
-  for (var sawDefault = false; this.type != types.braceR;) {
-    if (this$1.type === types._case || this$1.type === types._default) {
-      var isCase = this$1.type === types._case;
-      if (cur) { this$1.finishNode(cur, "SwitchCase"); }
-      node.cases.push(cur = this$1.startNode());
-      cur.consequent = [];
-      this$1.next();
-      if (isCase) {
-        cur.test = this$1.parseExpression();
-      } else {
-        if (sawDefault) { this$1.raiseRecoverable(this$1.lastTokStart, "Multiple default clauses"); }
-        sawDefault = true;
-        cur.test = null;
-      }
-      this$1.expect(types.colon);
-    } else {
-      if (!cur) { this$1.unexpected(); }
-      cur.consequent.push(this$1.parseStatement(true));
-    }
-  }
-  this.exitLexicalScope();
-  if (cur) { this.finishNode(cur, "SwitchCase"); }
-  this.next(); // Closing brace
-  this.labels.pop();
-  return this.finishNode(node, "SwitchStatement")
-};
+				switch (unrolled_lc) {
+					case 'this.thread.x':
+						retArr.push('threadId.x');
+						break;
+					case 'this.thread.y':
+						retArr.push('threadId.y');
+						break;
+					case 'this.thread.z':
+						retArr.push('threadId.z');
+						break;
+					case 'this.output.x':
+						retArr.push(this.output[0] + '.0');
+						break;
+					case 'this.output.y':
+						retArr.push(this.output[1] + '.0');
+						break;
+					case 'this.output.z':
+						retArr.push(this.output[2] + '.0');
+						break;
+					default:
+						retArr.push(unrolled);
+				}
+			}
+			return retArr;
+		}
+	}, {
+		key: 'astSequenceExpression',
+		value: function astSequenceExpression(sNode, retArr, funcParam) {
+			for (var i = 0; i < sNode.expressions.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
+				}
+				this.astGeneric(sNode.expressions, retArr, funcParam);
+			}
+			return retArr;
+		}
 
-pp$1.parseThrowStatement = function(node) {
-  this.next();
-  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
-    { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
-  node.argument = this.parseExpression();
-  this.semicolon();
-  return this.finishNode(node, "ThrowStatement")
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astCallExpression
+   *
+   * @desc Parses the abstract syntax tree for *call* expression
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns  {Array} the append retArr
+   */
 
-// Reused empty array added for node fields that are always empty.
+	}, {
+		key: 'astCallExpression',
+		value: function astCallExpression(ast, retArr, funcParam) {
+			if (ast.callee) {
+				// Get the full function call, unrolled
+				var funcName = this.astMemberExpressionUnroll(ast.callee);
 
-var empty = [];
+				// Its a math operator, remove the prefix
+				if (funcName.indexOf(jsMathPrefix) === 0) {
+					funcName = funcName.slice(jsMathPrefix.length);
+				}
 
-pp$1.parseTryStatement = function(node) {
-  this.next();
-  node.block = this.parseBlock();
-  node.handler = null;
-  if (this.type === types._catch) {
-    var clause = this.startNode();
-    this.next();
-    this.expect(types.parenL);
-    clause.param = this.parseBindingAtom();
-    this.enterLexicalScope();
-    this.checkLVal(clause.param, "let");
-    this.expect(types.parenR);
-    clause.body = this.parseBlock(false);
-    this.exitLexicalScope();
-    node.handler = this.finishNode(clause, "CatchClause");
-  }
-  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
-  if (!node.handler && !node.finalizer)
-    { this.raise(node.start, "Missing catch or finally clause"); }
-  return this.finishNode(node, "TryStatement")
-};
+				// Its a local function, remove this
+				if (funcName.indexOf(localPrefix) === 0) {
+					funcName = funcName.slice(localPrefix.length);
+				}
 
-pp$1.parseVarStatement = function(node, kind) {
-  this.next();
-  this.parseVar(node, false, kind);
-  this.semicolon();
-  return this.finishNode(node, "VariableDeclaration")
-};
+				// Register the function into the called registry
+				if (funcParam.calledFunctions.indexOf(funcName) < 0) {
+					funcParam.calledFunctions.push(funcName);
+				}
+				if (!funcParam.hasOwnProperty('funcName')) {
+					funcParam.calledFunctionsArguments[funcName] = [];
+				}
 
-pp$1.parseWhileStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "WhileStatement")
-};
+				var functionArguments = [];
+				funcParam.calledFunctionsArguments[funcName].push(functionArguments);
 
-pp$1.parseWithStatement = function(node) {
-  if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
-  this.next();
-  node.object = this.parseParenExpression();
-  node.body = this.parseStatement(false);
-  return this.finishNode(node, "WithStatement")
-};
+				// Call the function
+				retArr.push(funcName);
 
-pp$1.parseEmptyStatement = function(node) {
-  this.next();
-  return this.finishNode(node, "EmptyStatement")
-};
+				// Open arguments space
+				retArr.push('(');
 
-pp$1.parseLabeledStatement = function(node, maybeName, expr) {
-  var this$1 = this;
+				// Add the vars
+				for (var i = 0; i < ast.arguments.length; ++i) {
+					var argument = ast.arguments[i];
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					this.astGeneric(argument, retArr, funcParam);
+					if (argument.type === 'Identifier') {
+						var paramIndex = funcParam.paramNames.indexOf(argument.name);
+						if (paramIndex === -1) {
+							functionArguments.push(null);
+						} else {
+							functionArguments.push({
+								name: argument.name,
+								type: funcParam.paramTypes[paramIndex]
+							});
+						}
+					} else {
+						functionArguments.push(null);
+					}
+				}
 
-  for (var i$1 = 0, list = this$1.labels; i$1 < list.length; i$1 += 1)
-    {
-    var label = list[i$1];
+				// Close arguments space
+				retArr.push(')');
 
-    if (label.name === maybeName)
-      { this$1.raise(expr.start, "Label '" + maybeName + "' is already declared");
-  } }
-  var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
-  for (var i = this.labels.length - 1; i >= 0; i--) {
-    var label$1 = this$1.labels[i];
-    if (label$1.statementStart == node.start) {
-      // Update information about previous labels on this node
-      label$1.statementStart = this$1.start;
-      label$1.kind = kind;
-    } else { break }
-  }
-  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
-  node.body = this.parseStatement(true);
-  if (node.body.type == "ClassDeclaration" ||
-      node.body.type == "VariableDeclaration" && node.body.kind != "var" ||
-      node.body.type == "FunctionDeclaration" && (this.strict || node.body.generator))
-    { this.raiseRecoverable(node.body.start, "Invalid labeled declaration"); }
-  this.labels.pop();
-  node.label = expr;
-  return this.finishNode(node, "LabeledStatement")
-};
+				return retArr;
+			}
 
-pp$1.parseExpressionStatement = function(node, expr) {
-  node.expression = expr;
-  this.semicolon();
-  return this.finishNode(node, "ExpressionStatement")
-};
+			// Failure, unknown expression
+			throw this.astErrorOutput('Unknown CallExpression', ast, funcParam);
 
-// Parse a semicolon-enclosed block of statements, handling `"use
-// strict"` declarations when `allowStrict` is true (used for
-// function bodies).
+			return retArr;
+		}
 
-pp$1.parseBlock = function(createNewLexicalScope) {
-  var this$1 = this;
-  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name astArrayExpression
+   *
+   * @desc Parses the abstract syntax tree for *Array* Expression
+   *
+   * @param {Object} ast - the AST object to parse
+   * @param {Array} retArr - return array string
+   * @param {Function} funcParam - FunctionNode, that tracks compilation state
+   *
+   * @returns {Array} the append retArr
+   */
 
-  var node = this.startNode();
-  node.body = [];
-  this.expect(types.braceL);
-  if (createNewLexicalScope) {
-    this.enterLexicalScope();
-  }
-  while (!this.eat(types.braceR)) {
-    var stmt = this$1.parseStatement(true);
-    node.body.push(stmt);
-  }
-  if (createNewLexicalScope) {
-    this.exitLexicalScope();
-  }
-  return this.finishNode(node, "BlockStatement")
-};
+	}, {
+		key: 'astArrayExpression',
+		value: function astArrayExpression(arrNode, retArr, funcParam) {
+			var arrLen = arrNode.elements.length;
 
-// Parse a regular `for` loop. The disambiguation code in
-// `parseStatement` will already have parsed the init statement or
-// expression.
+			retArr.push('float[' + arrLen + '](');
+			for (var i = 0; i < arrLen; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+				var subNode = arrNode.elements[i];
+				this.astGeneric(subNode, retArr, funcParam);
+			}
+			retArr.push(')');
 
-pp$1.parseFor = function(node, init) {
-  node.init = init;
-  this.expect(types.semi);
-  node.test = this.type === types.semi ? null : this.parseExpression();
-  this.expect(types.semi);
-  node.update = this.type === types.parenR ? null : this.parseExpression();
-  this.expect(types.parenR);
-  this.exitLexicalScope();
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "ForStatement")
-};
+			return retArr;
 
-// Parse a `for`/`in` and `for`/`of` loop, which are almost
-// same from parser's perspective.
+			// // Failure, unknown expression
+			// throw this.astErrorOutput(
+			// 	'Unknown  ArrayExpression',
+			// 	arrNode, funcParam
+			//);
+		}
 
-pp$1.parseForIn = function(node, init) {
-  var type = this.type === types._in ? "ForInStatement" : "ForOfStatement";
-  this.next();
-  if (type == "ForInStatement") {
-    if (init.type === "AssignmentPattern" ||
-      (init.type === "VariableDeclaration" && init.declarations[0].init != null &&
-       (this.strict || init.declarations[0].id.type !== "Identifier")))
-      { this.raise(init.start, "Invalid assignment in for-in loop head"); }
-  }
-  node.left = init;
-  node.right = type == "ForInStatement" ? this.parseExpression() : this.parseMaybeAssign();
-  this.expect(types.parenR);
-  this.exitLexicalScope();
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, type)
-};
+		/**
+   * @memberOf WebGLFunctionNode#
+   * @function
+   * @name getFunctionPrototypeString
+   *
+   * @desc Returns the converted webgl shader function equivalent of the JS function
+   *
+   * @returns {String} webgl function string, result is cached under this.getFunctionPrototypeString
+   *
+   */
+
+	}, {
+		key: 'getFunctionPrototypeString',
+		value: function getFunctionPrototypeString() {
+			if (this.webGlFunctionPrototypeString) {
+				return this.webGlFunctionPrototypeString;
+			}
+			return this.webGlFunctionPrototypeString = this.generate();
+		}
+	}, {
+		key: 'build',
+		value: function build() {
+			return this.getFunctionPrototypeString().length > 0;
+		}
+	}], [{
+		key: 'astFunctionPrototype',
+		value: function astFunctionPrototype(ast, retArr, funcParam) {
+			// Setup function return type and name
+			if (funcParam.isRootKernel || funcParam.isSubKernel) {
+				return retArr;
+			}
 
-// Parse a list of variable declarations.
+			retArr.push(funcParam.returnType);
+			retArr.push(' ');
+			retArr.push(funcParam.functionName);
+			retArr.push('(');
 
-pp$1.parseVar = function(node, isFor, kind) {
-  var this$1 = this;
+			// Arguments handling
+			for (var i = 0; i < funcParam.paramNames.length; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
 
-  node.declarations = [];
-  node.kind = kind;
-  for (;;) {
-    var decl = this$1.startNode();
-    this$1.parseVarId(decl, kind);
-    if (this$1.eat(types.eq)) {
-      decl.init = this$1.parseMaybeAssign(isFor);
-    } else if (kind === "const" && !(this$1.type === types._in || (this$1.options.ecmaVersion >= 6 && this$1.isContextual("of")))) {
-      this$1.unexpected();
-    } else if (decl.id.type != "Identifier" && !(isFor && (this$1.type === types._in || this$1.isContextual("of")))) {
-      this$1.raise(this$1.lastTokEnd, "Complex binding patterns require an initialization value");
-    } else {
-      decl.init = null;
-    }
-    node.declarations.push(this$1.finishNode(decl, "VariableDeclarator"));
-    if (!this$1.eat(types.comma)) { break }
-  }
-  return node
-};
+				retArr.push(funcParam.paramTypes[i]);
+				retArr.push(' ');
+				retArr.push('user_');
+				retArr.push(funcParam.paramNames[i]);
+			}
 
-pp$1.parseVarId = function(decl, kind) {
-  decl.id = this.parseBindingAtom(kind);
-  this.checkLVal(decl.id, kind, false);
-};
+			retArr.push(');\n');
 
-// Parse a function declaration or literal (depending on the
-// `isStatement` parameter).
+			return retArr;
+		}
+	}]);
 
-pp$1.parseFunction = function(node, isStatement, allowExpressionBody, isAsync) {
-  this.initFunction(node);
-  if (this.options.ecmaVersion >= 6 && !isAsync)
-    { node.generator = this.eat(types.star); }
-  if (this.options.ecmaVersion >= 8)
-    { node.async = !!isAsync; }
+	return WebGLFunctionNode;
+}(FunctionNodeBase);
 
-  if (isStatement) {
-    node.id = isStatement === "nullableID" && this.type != types.name ? null : this.parseIdent();
-    if (node.id) {
-      this.checkLVal(node.id, "var");
-    }
-  }
+function isIdentifierKernelParam(paramName, ast, funcParam) {
+	return funcParam.paramNames.indexOf(paramName) !== -1;
+}
 
-  var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
-      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
-  this.inGenerator = node.generator;
-  this.inAsync = node.async;
-  this.yieldPos = 0;
-  this.awaitPos = 0;
-  this.inFunction = true;
-  this.enterFunctionScope();
+function ensureIndentifierType(paramName, expectedType, ast, funcParam) {
+	var start = ast.loc.start;
 
-  if (!isStatement)
-    { node.id = this.type == types.name ? this.parseIdent() : null; }
+	if (!isIdentifierKernelParam(paramName, funcParam) && expectedType !== 'float') {
+		throw new Error('Error unexpected identifier ' + paramName + ' on line ' + start.line);
+	} else {
+		var actualType = funcParam.paramTypes[funcParam.paramNames.indexOf(paramName)];
+		if (actualType !== expectedType) {
+			throw new Error('Error unexpected identifier ' + paramName + ' on line ' + start.line);
+		}
+	}
+}
 
-  this.parseFunctionParams(node);
-  this.parseFunctionBody(node, allowExpressionBody);
+/**
+ * @ignore
+ * @function
+ * @name webgl_regex_optimize
+ *
+ * @desc [INTERNAL] Takes the near final webgl function string, and do regex search and replacments.
+ * For voodoo optimize out the following: 
+ *
+ * - decode32(encode32( <br>
+ * - encode32(decode32( <br>
+ *
+ * @param {String} inStr - The webGl function String
+ *
+ */
+function webGlRegexOptimize(inStr) {
+	return inStr.replace(DECODE32_ENCODE32, '((').replace(ENCODE32_DECODE32, '((');
+}
+},{"../../core/utils":75,"../function-node-base":57}],63:[function(require,module,exports){
+'use strict';
 
-  this.inGenerator = oldInGen;
-  this.inAsync = oldInAsync;
-  this.yieldPos = oldYieldPos;
-  this.awaitPos = oldAwaitPos;
-  this.inFunction = oldInFunc;
-  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
-};
+var utils = require('../../core/utils');
+var kernelRunShortcut = require('../kernel-run-shortcut');
 
-pp$1.parseFunctionParams = function(node) {
-  this.expect(types.parenL);
-  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
-  this.checkYieldAwaitInDefaultParams();
+module.exports = function (gpuKernel, name) {
+  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: function ' + utils.allPropertiesOf.toString() + ',\n      clone: function ' + utils.clone.toString() + ',\n      splitArray: function ' + utils.splitArray.toString() + ',\n      getArgumentType: function ' + utils.getArgumentType.toString() + ',\n      getDimensions: function ' + utils.getDimensions.toString() + ',\n      dimToTexSize: function ' + utils.dimToTexSize.toString() + ',\n      copyFlatten: function ' + utils.copyFlatten.toString() + ',\n      flatten: function ' + utils.flatten.toString() + ',\n      systemEndianness: \'' + utils.systemEndianness() + '\',\n      initWebGl: function ' + utils.initWebGl.toString() + ',\n      isArray: function ' + utils.isArray.toString() + '\n    };\n    class ' + (name || 'Kernel') + ' {\n      constructor() {\n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = ' + JSON.stringify(gpuKernel.paramNames) + ';\n        this.paramTypes = ' + JSON.stringify(gpuKernel.paramTypes) + ';\n        this.texSize = ' + JSON.stringify(gpuKernel.texSize) + ';\n        this.output = ' + JSON.stringify(gpuKernel.output) + ';\n        this.compiledFragShaderString = `' + gpuKernel.compiledFragShaderString + '`;\n\t\t    this.compiledVertShaderString = `' + gpuKernel.compiledVertShaderString + '`;\n\t\t    this.programUniformLocationCache = {};\n\t\t    this.textureCache = {};\n\t\t    this.subKernelOutputTextures = null;\n      }\n      ' + gpuKernel._getFragShaderString.toString() + '\n      ' + gpuKernel._getVertShaderString.toString() + '\n      validateOptions() {}\n      setupParams() {}\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      ' + gpuKernel.getUniformLocation.toString() + '\n      ' + gpuKernel.setupParams.toString() + '\n      ' + gpuKernel.build.toString() + '\n\t\t  ' + gpuKernel.run.toString() + '\n\t\t  ' + gpuKernel._addArgument.toString() + '\n\t\t  ' + gpuKernel.getArgumentTexture.toString() + '\n\t\t  ' + gpuKernel.getTextureCache.toString() + '\n\t\t  ' + gpuKernel.getOutputTexture.toString() + '\n\t\t  ' + gpuKernel.renderOutput.toString() + '\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
 };
+},{"../../core/utils":75,"../kernel-run-shortcut":59}],64:[function(require,module,exports){
+'use strict';
 
-// Parse a class declaration or literal (depending on the
-// `isStatement` parameter).
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-pp$1.parseClass = function(node, isStatement) {
-  var this$1 = this;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  this.next();
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-  this.parseClassId(node, isStatement);
-  this.parseClassSuper(node);
-  var classBody = this.startNode();
-  var hadConstructor = false;
-  classBody.body = [];
-  this.expect(types.braceL);
-  while (!this.eat(types.braceR)) {
-    var member = this$1.parseClassMember(classBody);
-    if (member && member.type === "MethodDefinition" && member.kind === "constructor") {
-      if (hadConstructor) { this$1.raise(member.start, "Duplicate constructor in the same class"); }
-      hadConstructor = true;
-    }
-  }
-  node.body = this.finishNode(classBody, "ClassBody");
-  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
-};
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-pp$1.parseClassMember = function(classBody) {
-  var this$1 = this;
+var KernelBase = require('../kernel-base');
+var utils = require('../../core/utils');
+var Texture = require('../../core/texture');
+var fragShaderString = require('./shader-frag');
+var vertShaderString = require('./shader-vert');
+var kernelString = require('./kernel-string');
+var canvases = [];
+var maxTexSizes = {};
 
-  if (this.eat(types.semi)) { return null }
+module.exports = function (_KernelBase) {
+	_inherits(WebGLKernel, _KernelBase);
 
-  var method = this.startNode();
-  var tryContextual = function (k, noLineBreak) {
-    if ( noLineBreak === void 0 ) noLineBreak = false;
+	/**
+  * @constructor WebGLKernel
+  *
+  * @desc Kernel Implementation for WebGL.
+  * <p>This builds the shaders and runs them on the GPU,
+  * the outputs the result back as float(enabled by default) and Texture.</p>
+  *
+  * @extends KernelBase
+  *
+  * @prop {Object} textureCache - webGl Texture cache
+  * @prop {Object} threadDim - The thread dimensions, x, y and z
+  * @prop {Object} programUniformLocationCache - Location of program variables in memory
+  * @prop {Object} framebuffer - Webgl frameBuffer
+  * @prop {Object} buffer - WebGL buffer
+  * @prop {Object} program - The webGl Program
+  * @prop {Object} functionBuilder - Function Builder instance bound to this Kernel
+  * @prop {Boolean} outputToTexture - Set output type to Texture, instead of float
+  * @prop {String} endianness - Endian information like Little-endian, Big-endian.
+  * @prop {Array} paramTypes - Types of parameters sent to the Kernel
+  * @prop {number} argumentsLength - Number of parameters sent to the Kernel
+  * @prop {String} compiledFragShaderString - Compiled fragment shader string
+  * @prop {String} compiledVertShaderString - Compiled Vertical shader string
+  */
+	function WebGLKernel(fnString, settings) {
+		_classCallCheck(this, WebGLKernel);
 
-    var start = this$1.start, startLoc = this$1.startLoc;
-    if (!this$1.eatContextual(k)) { return false }
-    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
-    if (method.key) { this$1.unexpected(); }
-    method.computed = false;
-    method.key = this$1.startNodeAt(start, startLoc);
-    method.key.name = k;
-    this$1.finishNode(method.key, "Identifier");
-    return false
-  };
+		var _this = _possibleConstructorReturn(this, (WebGLKernel.__proto__ || Object.getPrototypeOf(WebGLKernel)).call(this, fnString, settings));
 
-  method.kind = "method";
-  method.static = tryContextual("static");
-  var isGenerator = this.eat(types.star);
-  var isAsync = false;
-  if (!isGenerator) {
-    if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
-      isAsync = true;
-    } else if (tryContextual("get")) {
-      method.kind = "get";
-    } else if (tryContextual("set")) {
-      method.kind = "set";
-    }
-  }
-  if (!method.key) { this.parsePropertyName(method); }
-  var key = method.key;
-  if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
-      key.type === "Literal" && key.value === "constructor")) {
-    if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
-    if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
-    if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
-    method.kind = "constructor";
-  } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
-    this.raise(key.start, "Classes may not have a static property named prototype");
-  }
-  this.parseClassMethod(classBody, method, isGenerator, isAsync);
-  if (method.kind === "get" && method.value.params.length !== 0)
-    { this.raiseRecoverable(method.value.start, "getter should have no params"); }
-  if (method.kind === "set" && method.value.params.length !== 1)
-    { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
-  if (method.kind === "set" && method.value.params[0].type === "RestElement")
-    { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
-  return method
-};
+		_this.textureCache = {};
+		_this.threadDim = {};
+		_this.programUniformLocationCache = {};
+		_this.framebuffer = null;
 
-pp$1.parseClassMethod = function(classBody, method, isGenerator, isAsync) {
-  method.value = this.parseMethod(isGenerator, isAsync);
-  classBody.body.push(this.finishNode(method, "MethodDefinition"));
-};
+		_this.buffer = null;
+		_this.program = null;
+		_this.outputToTexture = settings.outputToTexture;
+		_this.endianness = utils.systemEndianness();
+		_this.subKernelOutputTextures = null;
+		_this.subKernelOutputVariableNames = null;
+		_this.argumentsLength = 0;
+		_this.ext = null;
+		_this.compiledFragShaderString = null;
+		_this.compiledVertShaderString = null;
+		_this.extDrawBuffersMap = null;
+		_this.outputTexture = null;
+		_this.maxTexSize = null;
+		if (!_this._webGl) _this._webGl = utils.initWebGl(_this.getCanvas());
+		return _this;
+	}
+
+	/**
+  * @memberOf WebGLKernel#
+  * @function
+  * @name validateOptions
+  *
+  * @desc Validate options related to Kernel, such as
+  * floatOutputs and Textures, texSize, output,
+  * graphical output.
+  *
+  */
 
-pp$1.parseClassId = function(node, isStatement) {
-  node.id = this.type === types.name ? this.parseIdent() : isStatement === true ? this.unexpected() : null;
-};
 
-pp$1.parseClassSuper = function(node) {
-  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
-};
+	_createClass(WebGLKernel, [{
+		key: 'validateOptions',
+		value: function validateOptions() {
+			var isFloatReadPixel = utils.isFloatReadPixelsSupported();
+			if (this.floatTextures === true && !utils.OES_texture_float) {
+				throw new Error('Float textures are not supported on this browser');
+			} else if (this.floatOutput === true && this.floatOutputForce !== true && !isFloatReadPixel) {
+				throw new Error('Float texture outputs are not supported on this browser');
+			} else if (this.floatTextures === undefined && utils.OES_texture_float) {
+				this.floatTextures = true;
+				this.floatOutput = isFloatReadPixel;
+			}
 
-// Parses module export declaration.
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw new Error('Auto output only supported for kernels with only one input');
+				}
 
-pp$1.parseExport = function(node, exports) {
-  var this$1 = this;
+				var argType = utils.getArgumentType(arguments[0]);
+				if (argType === 'Array') {
+					this.output = utils.getDimensions(argType);
+				} else if (argType === 'Texture') {
+					this.output = arguments[0].output;
+				} else {
+					throw new Error('Auto output not supported for input type: ' + argType);
+				}
+			}
 
-  this.next();
-  // export * from '...'
-  if (this.eat(types.star)) {
-    this.expectContextual("from");
-    if (this.type !== types.string) { this.unexpected(); }
-    node.source = this.parseExprAtom();
-    this.semicolon();
-    return this.finishNode(node, "ExportAllDeclaration")
-  }
-  if (this.eat(types._default)) { // export default ...
-    this.checkExport(exports, "default", this.lastTokStart);
-    var isAsync;
-    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
-      var fNode = this.startNode();
-      this.next();
-      if (isAsync) { this.next(); }
-      node.declaration = this.parseFunction(fNode, "nullableID", false, isAsync);
-    } else if (this.type === types._class) {
-      var cNode = this.startNode();
-      node.declaration = this.parseClass(cNode, "nullableID");
-    } else {
-      node.declaration = this.parseMaybeAssign();
-      this.semicolon();
-    }
-    return this.finishNode(node, "ExportDefaultDeclaration")
-  }
-  // export var|const|let|function|class ...
-  if (this.shouldParseExportStatement()) {
-    node.declaration = this.parseStatement(true);
-    if (node.declaration.type === "VariableDeclaration")
-      { this.checkVariableExport(exports, node.declaration.declarations); }
-    else
-      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
-    node.specifiers = [];
-    node.source = null;
-  } else { // export { x, y as z } [from '...']
-    node.declaration = null;
-    node.specifiers = this.parseExportSpecifiers(exports);
-    if (this.eatContextual("from")) {
-      if (this.type !== types.string) { this.unexpected(); }
-      node.source = this.parseExprAtom();
-    } else {
-      // check for keywords used as local names
-      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
-        var spec = list[i];
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
 
-        this$1.checkUnreserved(spec.local);
-      }
+			if (this.graphical) {
+				if (this.output.length !== 2) {
+					throw new Error('Output must have 2 dimensions on graphical mode');
+				}
 
-      node.source = null;
-    }
-    this.semicolon();
-  }
-  return this.finishNode(node, "ExportNamedDeclaration")
-};
+				if (this.floatOutput) {
+					this.floatOutput = false;
+					console.warn('Cannot use graphical mode and float output at the same time');
+				}
 
-pp$1.checkExport = function(exports, name, pos) {
-  if (!exports) { return }
-  if (has(exports, name))
-    { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
-  exports[name] = true;
-};
+				this.texSize = utils.clone(this.output);
+			} else if (this.floatOutput === undefined && utils.OES_texture_float) {
+				this.floatOutput = true;
+			}
+		}
+	}, {
+		key: 'updateMaxTexSize',
+		value: function updateMaxTexSize() {
+			var texSize = this.texSize;
+			var canvas = this._canvas;
+			if (this.maxTexSize === null) {
+				var canvasIndex = canvases.indexOf(canvas);
+				if (canvasIndex === -1) {
+					canvasIndex = canvases.length;
+					canvases.push(canvas);
+					maxTexSizes[canvasIndex] = [texSize[0], texSize[1]];
+				}
+				this.maxTexSize = maxTexSizes[canvasIndex];
+			}
+			if (this.maxTexSize[0] < texSize[0]) {
+				this.maxTexSize[0] = texSize[0];
+			}
+			if (this.maxTexSize[1] < texSize[1]) {
+				this.maxTexSize[1] = texSize[1];
+			}
+		}
 
-pp$1.checkPatternExport = function(exports, pat) {
-  var this$1 = this;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name build
+   *
+   * @desc Builds the Kernel, by compiling Fragment and Vertical Shaders,
+   * and instantiates the program.
+   *
+   */
 
-  var type = pat.type;
-  if (type == "Identifier")
-    { this.checkExport(exports, pat.name, pat.start); }
-  else if (type == "ObjectPattern")
-    { for (var i = 0, list = pat.properties; i < list.length; i += 1)
-      {
-        var prop = list[i];
+	}, {
+		key: 'build',
+		value: function build() {
+			this.validateOptions();
+			this.setupParams(arguments);
+			this.updateMaxTexSize();
+			var texSize = this.texSize;
+			var gl = this._webGl;
+			var canvas = this._canvas;
+			gl.enable(gl.SCISSOR_TEST);
+			gl.viewport(0, 0, this.maxTexSize[0], this.maxTexSize[1]);
+			canvas.width = this.maxTexSize[0];
+			canvas.height = this.maxTexSize[1];
+			var threadDim = this.threadDim = utils.clone(this.output);
+			while (threadDim.length < 3) {
+				threadDim.push(1);
+			}
 
-        this$1.checkPatternExport(exports, prop.value);
-      } }
-  else if (type == "ArrayPattern")
-    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
-      var elt = list$1[i$1];
+			if (this.functionBuilder) this._addKernels();
 
-        if (elt) { this$1.checkPatternExport(exports, elt); }
-    } }
-  else if (type == "AssignmentPattern")
-    { this.checkPatternExport(exports, pat.left); }
-  else if (type == "ParenthesizedExpression")
-    { this.checkPatternExport(exports, pat.expression); }
-};
+			var compiledVertShaderString = this._getVertShaderString(arguments);
+			var vertShader = gl.createShader(gl.VERTEX_SHADER);
+			gl.shaderSource(vertShader, compiledVertShaderString);
+			gl.compileShader(vertShader);
 
-pp$1.checkVariableExport = function(exports, decls) {
-  var this$1 = this;
+			var compiledFragShaderString = this._getFragShaderString(arguments);
+			var fragShader = gl.createShader(gl.FRAGMENT_SHADER);
+			gl.shaderSource(fragShader, compiledFragShaderString);
+			gl.compileShader(fragShader);
 
-  if (!exports) { return }
-  for (var i = 0, list = decls; i < list.length; i += 1)
-    {
-    var decl = list[i];
+			if (!gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)) {
+				console.log(compiledVertShaderString);
+				console.error('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(vertShader));
+				throw new Error('Error compiling vertex shader');
+			}
+			if (!gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)) {
+				console.log(compiledFragShaderString);
+				console.error('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(fragShader));
+				throw new Error('Error compiling fragment shader');
+			}
 
-    this$1.checkPatternExport(exports, decl.id);
-  }
-};
+			if (this.debug) {
+				console.log('Options:');
+				console.dir(this);
+				console.log('GLSL Shader Output:');
+				console.log(compiledFragShaderString);
+			}
 
-pp$1.shouldParseExportStatement = function() {
-  return this.type.keyword === "var" ||
-    this.type.keyword === "const" ||
-    this.type.keyword === "class" ||
-    this.type.keyword === "function" ||
-    this.isLet() ||
-    this.isAsyncFunction()
-};
+			var program = this.program = gl.createProgram();
+			gl.attachShader(program, vertShader);
+			gl.attachShader(program, fragShader);
+			gl.linkProgram(program);
+			this.framebuffer = gl.createFramebuffer();
+			this.framebuffer.width = texSize[0];
+			this.framebuffer.height = texSize[1];
 
-// Parses a comma-separated list of module exports.
+			var vertices = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
+			var texCoords = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
 
-pp$1.parseExportSpecifiers = function(exports) {
-  var this$1 = this;
+			var texCoordOffset = vertices.byteLength;
 
-  var nodes = [], first = true;
-  // export { x, y as z } [from '...']
-  this.expect(types.braceL);
-  while (!this.eat(types.braceR)) {
-    if (!first) {
-      this$1.expect(types.comma);
-      if (this$1.afterTrailingComma(types.braceR)) { break }
-    } else { first = false; }
+			var buffer = this.buffer;
+			if (!buffer) {
+				buffer = this.buffer = gl.createBuffer();
+				gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+				gl.bufferData(gl.ARRAY_BUFFER, vertices.byteLength + texCoords.byteLength, gl.STATIC_DRAW);
+			} else {
+				gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+			}
 
-    var node = this$1.startNode();
-    node.local = this$1.parseIdent(true);
-    node.exported = this$1.eatContextual("as") ? this$1.parseIdent(true) : node.local;
-    this$1.checkExport(exports, node.exported.name, node.exported.start);
-    nodes.push(this$1.finishNode(node, "ExportSpecifier"));
-  }
-  return nodes
-};
+			gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
+			gl.bufferSubData(gl.ARRAY_BUFFER, texCoordOffset, texCoords);
 
-// Parses import declaration.
+			var aPosLoc = gl.getAttribLocation(this.program, 'aPos');
+			gl.enableVertexAttribArray(aPosLoc);
+			gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, gl.FALSE, 0, 0);
+			var aTexCoordLoc = gl.getAttribLocation(this.program, 'aTexCoord');
+			gl.enableVertexAttribArray(aTexCoordLoc);
+			gl.vertexAttribPointer(aTexCoordLoc, 2, gl.FLOAT, gl.FALSE, 0, texCoordOffset);
 
-pp$1.parseImport = function(node) {
-  this.next();
-  // import '...'
-  if (this.type === types.string) {
-    node.specifiers = empty;
-    node.source = this.parseExprAtom();
-  } else {
-    node.specifiers = this.parseImportSpecifiers();
-    this.expectContextual("from");
-    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
-  }
-  this.semicolon();
-  return this.finishNode(node, "ImportDeclaration")
-};
+			this.setupOutputTexture();
 
-// Parses a comma-separated list of module imports.
+			if (this.subKernelOutputTextures !== null) {
+				var extDrawBuffersMap = this.extDrawBuffersMap = [gl.COLOR_ATTACHMENT0];
+				for (var i = 0; i < this.subKernelOutputTextures.length; i++) {
+					var subKernelOutputTexture = this.subKernelOutputTextures[i];
+					extDrawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
+					gl.activeTexture(gl.TEXTURE0 + arguments.length + i);
+					gl.bindTexture(gl.TEXTURE_2D, subKernelOutputTexture);
+					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+					gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+					if (this.floatOutput) {
+						gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
+					} else {
+						gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+					}
+				}
+			}
+		}
 
-pp$1.parseImportSpecifiers = function() {
-  var this$1 = this;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name run
+   *
+   * @desc Run the kernel program, and send the output to renderOutput
+   *
+   * <p> This method calls a helper method *renderOutput* to return the result. </p>
+   *
+   * @returns {Object} Result The final output of the program, as float, and as Textures for reuse.
+   *
+   *
+   */
 
-  var nodes = [], first = true;
-  if (this.type === types.name) {
-    // import defaultObj, { x, y as z } from '...'
-    var node = this.startNode();
-    node.local = this.parseIdent();
-    this.checkLVal(node.local, "let");
-    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
-    if (!this.eat(types.comma)) { return nodes }
-  }
-  if (this.type === types.star) {
-    var node$1 = this.startNode();
-    this.next();
-    this.expectContextual("as");
-    node$1.local = this.parseIdent();
-    this.checkLVal(node$1.local, "let");
-    nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
-    return nodes
-  }
-  this.expect(types.braceL);
-  while (!this.eat(types.braceR)) {
-    if (!first) {
-      this$1.expect(types.comma);
-      if (this$1.afterTrailingComma(types.braceR)) { break }
-    } else { first = false; }
+	}, {
+		key: 'run',
+		value: function run() {
+			if (this.program === null) {
+				this.build.apply(this, arguments);
+			}
+			var paramNames = this.paramNames;
+			var paramTypes = this.paramTypes;
+			var texSize = this.texSize;
+			var gl = this._webGl;
 
-    var node$2 = this$1.startNode();
-    node$2.imported = this$1.parseIdent(true);
-    if (this$1.eatContextual("as")) {
-      node$2.local = this$1.parseIdent();
-    } else {
-      this$1.checkUnreserved(node$2.imported);
-      node$2.local = node$2.imported;
-    }
-    this$1.checkLVal(node$2.local, "let");
-    nodes.push(this$1.finishNode(node$2, "ImportSpecifier"));
-  }
-  return nodes
-};
+			gl.useProgram(this.program);
+			gl.scissor(0, 0, texSize[0], texSize[1]);
 
-// Set `ExpressionStatement#directive` property for directive prologues.
-pp$1.adaptDirectivePrologue = function(statements) {
-  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
-    statements[i].directive = statements[i].expression.raw.slice(1, -1);
-  }
-};
-pp$1.isDirectiveCandidate = function(statement) {
-  return (
-    statement.type === "ExpressionStatement" &&
-    statement.expression.type === "Literal" &&
-    typeof statement.expression.value === "string" &&
-    // Reject parenthesized strings.
-    (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
-  )
-};
+			if (!this.hardcodeConstants) {
+				var uOutputDimLoc = this.getUniformLocation('uOutputDim');
+				gl.uniform3fv(uOutputDimLoc, this.threadDim);
+				var uTexSizeLoc = this.getUniformLocation('uTexSize');
+				gl.uniform2fv(uTexSizeLoc, texSize);
+			}
 
-var pp$2 = Parser.prototype;
+			var ratioLoc = this.getUniformLocation('ratio');
+			gl.uniform2f(ratioLoc, texSize[0] / this.maxTexSize[0], texSize[1] / this.maxTexSize[1]);
 
-// Convert existing expression atom to assignable pattern
-// if possible.
+			this.argumentsLength = 0;
+			for (var texIndex = 0; texIndex < paramNames.length; texIndex++) {
+				this._addArgument(arguments[texIndex], paramTypes[texIndex], paramNames[texIndex]);
+			}
 
-pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
-  var this$1 = this;
+			if (this.graphical) {
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+				return;
+			}
 
-  if (this.options.ecmaVersion >= 6 && node) {
-    switch (node.type) {
-    case "Identifier":
-      if (this.inAsync && node.name === "await")
-        { this.raise(node.start, "Can not use 'await' as identifier inside an async function"); }
-      break
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+			//the call to this._addArgument may rewrite the outputTexture, keep this here
+			var outputTexture = this.outputTexture;
+			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
 
-    case "ObjectPattern":
-    case "ArrayPattern":
-    case "RestElement":
-      break
+			if (this.subKernelOutputTextures !== null) {
+				for (var i = 0; i < this.subKernelOutputTextures.length; i++) {
+					var subKernelOutputTexture = this.subKernelOutputTextures[i];
+					gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, subKernelOutputTexture, 0);
+				}
+				this.ext.drawBuffersWEBGL(this.extDrawBuffersMap);
+			}
 
-    case "ObjectExpression":
-      node.type = "ObjectPattern";
-      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
-      for (var i = 0, list = node.properties; i < list.length; i += 1)
-        {
-      var prop = list[i];
+			gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
 
-      this$1.toAssignable(prop, isBinding);
-    }
-      break
+			if (this.subKernelOutputTextures !== null) {
+				if (this.subKernels !== null) {
+					var output = [];
+					output.result = this.renderOutput(outputTexture);
+					for (var _i = 0; _i < this.subKernels.length; _i++) {
+						output.push(new Texture(this.subKernelOutputTextures[_i], texSize, this.output, this._webGl));
+					}
+					return output;
+				} else if (this.subKernelProperties !== null) {
+					var _output = {
+						result: this.renderOutput(outputTexture)
+					};
+					var _i2 = 0;
+					for (var p in this.subKernelProperties) {
+						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+						_output[p] = new Texture(this.subKernelOutputTextures[_i2], texSize, this.output, this._webGl);
+						_i2++;
+					}
+					return _output;
+				}
+			}
 
-    case "Property":
-      // AssignmentProperty has type == "Property"
-      if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
-      this.toAssignable(node.value, isBinding);
-      break
+			return this.renderOutput(outputTexture);
+		}
 
-    case "ArrayExpression":
-      node.type = "ArrayPattern";
-      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
-      this.toAssignableList(node.elements, isBinding);
-      break
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name renderOutput
+   *
+   *
+   * @desc Helper function to return webGl function's output.
+   * Since the program runs on GPU, we need to get the
+   * output of the program back to CPU and then return them.
+   *
+   * *Note*: This should not be called directly.
+   *
+   * @param {Object} outputTexture - Output Texture returned by webGl program
+   *
+   * @returns {Object|Array} result
+   *
+   *
+   */
 
-    case "SpreadElement":
-      node.type = "RestElement";
-      this.toAssignable(node.argument, isBinding);
-      if (node.argument.type === "AssignmentPattern")
-        { this.raise(node.argument.start, "Rest elements cannot have a default value"); }
-      break
+	}, {
+		key: 'renderOutput',
+		value: function renderOutput(outputTexture) {
+			var texSize = this.texSize;
+			var gl = this._webGl;
+			var threadDim = this.threadDim;
+			var output = this.output;
+			if (this.outputToTexture) {
+				return new Texture(outputTexture, texSize, output, this._webGl);
+			} else {
+				var result = void 0;
+				if (this.floatOutput) {
+					result = new Float32Array(texSize[0] * texSize[1] * 4);
+					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.FLOAT, result);
+				} else {
+					var bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
+					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
+					result = new Float32Array(bytes.buffer);
+				}
 
-    case "AssignmentExpression":
-      if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
-      node.type = "AssignmentPattern";
-      delete node.operator;
-      this.toAssignable(node.left, isBinding);
-      // falls through to AssignmentPattern
+				result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
 
-    case "AssignmentPattern":
-      break
+				if (output.length === 1) {
+					return result;
+				} else if (output.length === 2) {
+					return utils.splitArray(result, output[0]);
+				} else if (output.length === 3) {
+					var cube = utils.splitArray(result, output[0] * output[1]);
+					return cube.map(function (x) {
+						return utils.splitArray(x, output[0]);
+					});
+				}
+			}
+		}
 
-    case "ParenthesizedExpression":
-      this.toAssignable(node.expression, isBinding);
-      break
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name getOutputTexture
+   *
+   * @desc This uses *getTextureCache* to get the Texture Cache of the Output
+   *
+   * @returns {Object} Ouptut Texture Cache
+   *
+   */
 
-    case "MemberExpression":
-      if (!isBinding) { break }
+	}, {
+		key: 'getOutputTexture',
+		value: function getOutputTexture() {
+			return this.getTextureCache('OUTPUT');
+		}
 
-    default:
-      this.raise(node.start, "Assigning to rvalue");
-    }
-  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
-  return node
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name detachOutputTexture
+   *
+   * @desc Detaches output texture
+   *
+   *
+   */
 
-// Convert list of expression atoms to binding list.
+	}, {
+		key: 'detachOutputTexture',
+		value: function detachOutputTexture() {
+			this.detachTextureCache('OUTPUT');
+		}
 
-pp$2.toAssignableList = function(exprList, isBinding) {
-  var this$1 = this;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name setupOutputTexture
+   *
+   * @desc Detaches a texture from cache if exists, and sets up output texture
+   */
 
-  var end = exprList.length;
-  for (var i = 0; i < end; i++) {
-    var elt = exprList[i];
-    if (elt) { this$1.toAssignable(elt, isBinding); }
-  }
-  if (end) {
-    var last = exprList[end - 1];
-    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
-      { this.unexpected(last.argument.start); }
-  }
-  return exprList
-};
+	}, {
+		key: 'setupOutputTexture',
+		value: function setupOutputTexture() {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			this.detachOutputTexture();
+			this.outputTexture = this.getOutputTexture();
+			gl.activeTexture(gl.TEXTURE0 + this.paramNames.length);
+			gl.bindTexture(gl.TEXTURE_2D, this.outputTexture);
+			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+			if (this.floatOutput) {
+				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
+			} else {
+				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+			}
+		}
 
-// Parses spread element.
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name getArgumentTexture
+   *
+   * @desc This uses *getTextureCache** to get the Texture Cache of the argument supplied
+   *
+   * @param {String} name - Name of the argument
+   *
+   * 	Texture cache for the supplied argument
+   *
+   */
 
-pp$2.parseSpread = function(refDestructuringErrors) {
-  var node = this.startNode();
-  this.next();
-  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
-  return this.finishNode(node, "SpreadElement")
-};
+	}, {
+		key: 'getArgumentTexture',
+		value: function getArgumentTexture(name) {
+			return this.getTextureCache('ARGUMENT_' + name);
+		}
 
-pp$2.parseRestBinding = function() {
-  var node = this.startNode();
-  this.next();
+		/**
+   * @memberOf WebGLKernel#
+   * @name getSubKernelTexture
+   * @function
+   *
+   * @desc This uses *getTextureCache* to get the Texture Cache of the sub-kernel
+   *
+   * @param {String} name - Name of the subKernel
+   *
+   * @returns {Object} Texture cache for the subKernel
+   *
+   */
 
-  // RestElement inside of a function parameter must be an identifier
-  if (this.options.ecmaVersion === 6 && this.type !== types.name)
-    { this.unexpected(); }
+	}, {
+		key: 'getSubKernelTexture',
+		value: function getSubKernelTexture(name) {
+			return this.getTextureCache('SUB_KERNEL_' + name);
+		}
 
-  node.argument = this.parseBindingAtom();
+		/**
+   * @memberOf WebGLKernel#
+   * @name getTextureCache
+   * @function
+   *
+   * @desc Returns the Texture Cache of the supplied parameter (can be kernel, sub-kernel or argument)
+   *
+   * @param {String} name - Name of the subkernel, argument, or kernel.
+   *
+   * @returns {Object} Texture cache
+   *
+   */
 
-  return this.finishNode(node, "RestElement")
-};
+	}, {
+		key: 'getTextureCache',
+		value: function getTextureCache(name) {
+			if (this.outputToTexture) {
+				// Don't retain a handle on the output texture, we might need to render on the same texture later
+				return this._webGl.createTexture();
+			}
+			if (this.textureCache.hasOwnProperty(name)) {
+				return this.textureCache[name];
+			}
+			return this.textureCache[name] = this._webGl.createTexture();
+		}
 
-// Parses lvalue (assignable) atom.
+		/**
+   * @memberOf WebGLKernel#
+   * @name detachTextureCache
+   * @function
+   * @desc removes a texture from the kernel's cache
+   * @param {String} name - Name of texture
+   */
 
-pp$2.parseBindingAtom = function() {
-  if (this.options.ecmaVersion >= 6) {
-    switch (this.type) {
-    case types.bracketL:
-      var node = this.startNode();
-      this.next();
-      node.elements = this.parseBindingList(types.bracketR, true, true);
-      return this.finishNode(node, "ArrayPattern")
+	}, {
+		key: 'detachTextureCache',
+		value: function detachTextureCache(name) {
+			delete this.textureCache[name];
+		}
 
-    case types.braceL:
-      return this.parseObj(true)
-    }
-  }
-  return this.parseIdent()
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name getUniformLocation
+   *
+   * @desc Return WebGlUniformLocation for various variables
+   * related to webGl program, such as user-defiend variables,
+   * as well as, dimension sizes, etc.
+   *
+   */
 
-pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
-  var this$1 = this;
+	}, {
+		key: 'getUniformLocation',
+		value: function getUniformLocation(name) {
+			var location = this.programUniformLocationCache[name];
+			if (!location) {
+				location = this._webGl.getUniformLocation(this.program, name);
+				this.programUniformLocationCache[name] = location;
+			}
+			return location;
+		}
 
-  var elts = [], first = true;
-  while (!this.eat(close)) {
-    if (first) { first = false; }
-    else { this$1.expect(types.comma); }
-    if (allowEmpty && this$1.type === types.comma) {
-      elts.push(null);
-    } else if (allowTrailingComma && this$1.afterTrailingComma(close)) {
-      break
-    } else if (this$1.type === types.ellipsis) {
-      var rest = this$1.parseRestBinding();
-      this$1.parseBindingListItem(rest);
-      elts.push(rest);
-      if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
-      this$1.expect(close);
-      break
-    } else {
-      var elem = this$1.parseMaybeDefault(this$1.start, this$1.startLoc);
-      this$1.parseBindingListItem(elem);
-      elts.push(elem);
-    }
-  }
-  return elts
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getFragShaderArtifactMap
+   *
+   * @desc Generate Shader artifacts for the kernel program.
+   * The final object contains HEADER, KERNEL, MAIN_RESULT, and others.
+   *
+   * @param {Array} args - The actual parameters sent to the Kernel
+   *
+   * @returns {Object} An object containing the Shader Artifacts(CONSTANTS, HEADER, KERNEL, etc.)
+   *
+   */
 
-pp$2.parseBindingListItem = function(param) {
-  return param
-};
+	}, {
+		key: '_getFragShaderArtifactMap',
+		value: function _getFragShaderArtifactMap(args) {
+			return {
+				HEADER: this._getHeaderString(),
+				LOOP_MAX: this._getLoopMaxString(),
+				CONSTANTS: this._getConstantsString(),
+				DECODE32_ENDIANNESS: this._getDecode32EndiannessString(),
+				ENCODE32_ENDIANNESS: this._getEncode32EndiannessString(),
+				GET_WRAPAROUND: this._getGetWraparoundString(),
+				GET_TEXTURE_CHANNEL: this._getGetTextureChannelString(),
+				GET_TEXTURE_INDEX: this._getGetTextureIndexString(),
+				GET_RESULT: this._getGetResultString(),
+				MAIN_PARAMS: this._getMainParamsString(args),
+				MAIN_CONSTANTS: this._getMainConstantsString(),
+				KERNEL: this._getKernelString(),
+				MAIN_RESULT: this._getMainResultString()
+			};
+		}
 
-// Parses assignment pattern around given atom if possible.
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _addArgument
+   *
+   * @desc Adds kernel parameters to the Argument Texture,
+   * binding it to the webGl instance, etc.
+   *
+   * @param {Array|Texture|Number} value - The actual argument supplied to the kernel
+   * @param {String} type - Type of the argument
+   * @param {String} name - Name of the argument
+   *
+   */
 
-pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
-  left = left || this.parseBindingAtom();
-  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
-  var node = this.startNodeAt(startPos, startLoc);
-  node.left = left;
-  node.right = this.parseMaybeAssign();
-  return this.finishNode(node, "AssignmentPattern")
-};
+	}, {
+		key: '_addArgument',
+		value: function _addArgument(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = 'Texture';
+			}
+			switch (type) {
+				case 'Array':
+					{
+						var dim = utils.getDimensions(value, true);
+						var size = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, dim);
+						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
 
-// Verify that a node is an lval — something that can be assigned
-// to.
-// bindingType can be either:
-// 'var' indicating that the lval creates a 'var' binding
-// 'let' indicating that the lval creates a lexical ('let' or 'const') binding
-// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references
+						var length = size[0] * size[1];
+						if (this.floatTextures) {
+							length *= 4;
+						}
 
-pp$2.checkLVal = function(expr, bindingType, checkClashes) {
-  var this$1 = this;
+						var valuesFlat = new Float32Array(length);
+						utils.flattenTo(value, valuesFlat);
 
-  switch (expr.type) {
-  case "Identifier":
-    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
-      { this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
-    if (checkClashes) {
-      if (has(checkClashes, expr.name))
-        { this.raiseRecoverable(expr.start, "Argument name clash"); }
-      checkClashes[expr.name] = true;
-    }
-    if (bindingType && bindingType !== "none") {
-      if (
-        bindingType === "var" && !this.canDeclareVarName(expr.name) ||
-        bindingType !== "var" && !this.canDeclareLexicalName(expr.name)
-      ) {
-        this.raiseRecoverable(expr.start, ("Identifier '" + (expr.name) + "' has already been declared"));
-      }
-      if (bindingType === "var") {
-        this.declareVarName(expr.name);
-      } else {
-        this.declareLexicalName(expr.name);
-      }
-    }
-    break
+						var buffer = void 0;
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
+						} else {
+							buffer = new Uint8Array(valuesFlat.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
 
-  case "MemberExpression":
-    if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
-    break
+						var loc = this.getUniformLocation('user_' + name);
+						var locSize = this.getUniformLocation('user_' + name + 'Size');
+						var dimLoc = this.getUniformLocation('user_' + name + 'Dim');
 
-  case "ObjectPattern":
-    for (var i = 0, list = expr.properties; i < list.length; i += 1)
-      {
-    var prop = list[i];
+						if (!this.hardcodeConstants) {
+							gl.uniform3fv(dimLoc, dim);
+							gl.uniform2fv(locSize, size);
+						}
+						gl.uniform1i(loc, this.argumentsLength);
+						break;
+					}
+				case 'Number':
+					{
+						var _loc = this.getUniformLocation('user_' + name);
+						gl.uniform1f(_loc, value);
+						break;
+					}
+				case 'Input':
+					{
+						var input = value;
+						var _dim = input.size;
+						var _size = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, _dim);
+						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
 
-    this$1.checkLVal(prop, bindingType, checkClashes);
-  }
-    break
+						var _length = _size[0] * _size[1];
+						var inputArray = void 0;
+						if (this.floatTextures) {
+							_length *= 4;
+							inputArray = new Float32Array(_length);
+							inputArray.set(input.value);
+						} else {
+							inputArray = input.value;
+						}
 
-  case "Property":
-    // AssignmentProperty has type == "Property"
-    this.checkLVal(expr.value, bindingType, checkClashes);
-    break
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0], _size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer = new Uint8Array(inputArray.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0], _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
+						}
 
-  case "ArrayPattern":
-    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
-      var elem = list$1[i$1];
+						var _loc2 = this.getUniformLocation('user_' + name);
+						var _locSize = this.getUniformLocation('user_' + name + 'Size');
+						var _dimLoc = this.getUniformLocation('user_' + name + 'Dim');
 
-    if (elem) { this$1.checkLVal(elem, bindingType, checkClashes); }
-    }
-    break
+						if (!this.hardcodeConstants) {
+							gl.uniform3fv(_dimLoc, _dim);
+							gl.uniform2fv(_locSize, _size);
+						}
+						gl.uniform1i(_loc2, this.argumentsLength);
+						break;
+					}
+				case 'Texture':
+					{
+						var inputTexture = value;
+						var _dim2 = utils.getDimensions(inputTexture, true);
 
-  case "AssignmentPattern":
-    this.checkLVal(expr.left, bindingType, checkClashes);
-    break
+						var _size2 = inputTexture.size;
 
-  case "RestElement":
-    this.checkLVal(expr.argument, bindingType, checkClashes);
-    break
+						if (inputTexture.texture === this.outputTexture) {
+							this.setupOutputTexture();
+						}
 
-  case "ParenthesizedExpression":
-    this.checkLVal(expr.expression, bindingType, checkClashes);
-    break
+						gl.activeTexture(gl.TEXTURE0 + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
 
-  default:
-    this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
-  }
-};
+						var _loc3 = this.getUniformLocation('user_' + name);
+						var _locSize2 = this.getUniformLocation('user_' + name + 'Size');
+						var _dimLoc2 = this.getUniformLocation('user_' + name + 'Dim');
 
-// A recursive descent parser operates by defining functions for all
-// syntactic elements, and recursively calling those, each function
-// advancing the input stream and returning an AST node. Precedence
-// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
-// instead of `(!x)[1]` is handled by the fact that the parser
-// function that parses unary prefix operators is called first, and
-// in turn calls the function that parses `[]` subscripts — that
-// way, it'll receive the node for `x[1]` already parsed, and wraps
-// *that* in the unary operator node.
-//
-// Acorn uses an [operator precedence parser][opp] to handle binary
-// operator precedence, because it is much more compact than using
-// the technique outlined above, which uses different, nesting
-// functions to specify precedence, for all of the ten binary
-// precedence levels that JavaScript defines.
-//
-// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
+						gl.uniform3fv(_dimLoc2, _dim2);
+						gl.uniform2fv(_locSize2, _size2);
+						gl.uniform1i(_loc3, this.argumentsLength);
+						break;
+					}
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+			this.argumentsLength++;
+		}
 
-var pp$3 = Parser.prototype;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getHeaderString
+   *
+   * @desc Get the header string for the program.
+   * This returns an empty string if no sub-kernels are defined.
+   *
+   * @returns {String} result
+   *
+   */
 
-// Check if property name clashes with already added.
-// Object/class getters and setters are not allowed to clash —
-// either with each other or with an init property — and in
-// strict mode, init properties are also not allowed to be repeated.
+	}, {
+		key: '_getHeaderString',
+		value: function _getHeaderString() {
+			return this.subKernels !== null || this.subKernelProperties !== null ?
+			//webgl2 '#version 300 es\n' :
+			'#extension GL_EXT_draw_buffers : require\n' : '';
+		}
 
-pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
-  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
-    { return }
-  var key = prop.key;
-  var name;
-  switch (key.type) {
-  case "Identifier": name = key.name; break
-  case "Literal": name = String(key.value); break
-  default: return
-  }
-  var kind = prop.kind;
-  if (this.options.ecmaVersion >= 6) {
-    if (name === "__proto__" && kind === "init") {
-      if (propHash.proto) {
-        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }
-        // Backwards-compat kludge. Can be removed in version 6.0
-        else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
-      }
-      propHash.proto = true;
-    }
-    return
-  }
-  name = "$" + name;
-  var other = propHash[name];
-  if (other) {
-    var redefinition;
-    if (kind === "init") {
-      redefinition = this.strict && other.init || other.get || other.set;
-    } else {
-      redefinition = other.init || other[kind];
-    }
-    if (redefinition)
-      { this.raiseRecoverable(key.start, "Redefinition of property"); }
-  } else {
-    other = propHash[name] = {
-      init: false,
-      get: false,
-      set: false
-    };
-  }
-  other[kind] = true;
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getLoopMaxString
+   *
+   * @desc Get the maximum loop size String.
+   *
+   * @returns {String} result
+   *
+   */
 
-// ### Expression parsing
+	}, {
+		key: '_getLoopMaxString',
+		value: function _getLoopMaxString() {
+			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + '.0;\n' : ' 1000.0;\n';
+		}
 
-// These nest, from the most general expression type at the top to
-// 'atomic', nondivisible expression types at the bottom. Most of
-// the functions will simply let the function(s) below them parse,
-// and, *if* the syntactic construct they handle is present, wrap
-// the AST node that the inner parser gave them in another node.
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getConstantsString
+   *
+   * @desc Generate transpiled glsl Strings for constant parameters sent to a kernel
+   *
+   * They can be defined by *hardcodeConstants*
+   *
+   * @returns {String} result
+   *
+   */
 
-// Parse a full expression. The optional arguments are used to
-// forbid the `in` operator (in for loops initalization expressions)
-// and provide reference for storing '=' operator inside shorthand
-// property assignment in contexts where both object expression
-// and object pattern might appear (so it's possible to raise
-// delayed syntax error at correct position).
+	}, {
+		key: '_getConstantsString',
+		value: function _getConstantsString() {
+			var result = [];
+			var threadDim = this.threadDim;
+			var texSize = this.texSize;
+			if (this.hardcodeConstants) {
+				result.push('highp vec3 uOutputDim = vec3(' + threadDim[0] + ',' + threadDim[1] + ', ' + threadDim[2] + ')', 'highp vec2 uTexSize = vec2(' + texSize[0] + ', ' + texSize[1] + ')');
+			} else {
+				result.push('uniform highp vec3 uOutputDim', 'uniform highp vec2 uTexSize');
+			}
 
-pp$3.parseExpression = function(noIn, refDestructuringErrors) {
-  var this$1 = this;
+			return this._linesToString(result);
+		}
 
-  var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
-  if (this.type === types.comma) {
-    var node = this.startNodeAt(startPos, startLoc);
-    node.expressions = [expr];
-    while (this.eat(types.comma)) { node.expressions.push(this$1.parseMaybeAssign(noIn, refDestructuringErrors)); }
-    return this.finishNode(node, "SequenceExpression")
-  }
-  return expr
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getTextureCoordinate
+   *
+   * @desc Get texture coordinate string for the program
+   *
+   * @returns {String} result
+   *
+   */
 
-// Parse an assignment expression. This includes applications of
-// operators like `+=`.
+	}, {
+		key: '_getTextureCoordinate',
+		value: function _getTextureCoordinate() {
+			var names = this.subKernelOutputVariableNames;
+			if (names === null || names.length < 1) {
+				return 'varying highp vec2 vTexCoord;\n';
+			} else {
+				return 'out highp vec2 vTexCoord;\n';
+			}
+		}
 
-pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
-  if (this.inGenerator && this.isContextual("yield")) { return this.parseYield() }
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getDecode32EndiannessString
+   *
+   * @desc Get Decode32 endianness string for little-endian and big-endian
+   *
+   * @returns {String} result
+   *
+   */
 
-  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
-  if (refDestructuringErrors) {
-    oldParenAssign = refDestructuringErrors.parenthesizedAssign;
-    oldTrailingComma = refDestructuringErrors.trailingComma;
-    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
-  } else {
-    refDestructuringErrors = new DestructuringErrors;
-    ownDestructuringErrors = true;
-  }
+	}, {
+		key: '_getDecode32EndiannessString',
+		value: function _getDecode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
 
-  var startPos = this.start, startLoc = this.startLoc;
-  if (this.type == types.parenL || this.type == types.name)
-    { this.potentialArrowAt = this.start; }
-  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
-  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
-  if (this.type.isAssign) {
-    var node = this.startNodeAt(startPos, startLoc);
-    node.operator = this.value;
-    node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
-    if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }
-    refDestructuringErrors.shorthandAssign = -1; // reset because shorthand default was used correctly
-    this.checkLVal(left);
-    this.next();
-    node.right = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "AssignmentExpression")
-  } else {
-    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
-  }
-  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
-  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
-  return left
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getEncode32EndiannessString
+   *
+   * @desc Get Encode32 endianness string for little-endian and big-endian
+   *
+   * @returns {String} result
+   *
+   */
 
-// Parse a ternary conditional (`?:`) operator.
+	}, {
+		key: '_getEncode32EndiannessString',
+		value: function _getEncode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
 
-pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
-  var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseExprOps(noIn, refDestructuringErrors);
-  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  if (this.eat(types.question)) {
-    var node = this.startNodeAt(startPos, startLoc);
-    node.test = expr;
-    node.consequent = this.parseMaybeAssign();
-    this.expect(types.colon);
-    node.alternate = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "ConditionalExpression")
-  }
-  return expr
-};
+		/**
+   * @function
+   * @memberOf WebGLKernel#
+   * @name _getGetWraparoundString
+   *
+   * @returns {String} wraparound string
+   */
 
-// Start the precedence parser.
+	}, {
+		key: '_getGetWraparoundString',
+		value: function _getGetWraparoundString() {
+			return this.wraparound ? '  xyz = mod(xyz, texDim);\n' : '';
+		}
 
-pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
-  var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseMaybeUnary(refDestructuringErrors, false);
-  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  return expr.start == startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetTextureChannelString
+   *
+   */
 
-// Parse binary operators with the operator precedence parsing
-// algorithm. `left` is the left-hand side of the operator.
-// `minPrec` provides context that allows the function to stop and
-// defer further parser to one of its callers when it encounters an
-// operator that has a lower precedence than the set it is parsing.
+	}, {
+		key: '_getGetTextureChannelString',
+		value: function _getGetTextureChannelString() {
+			if (!this.floatTextures) return '';
 
-pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
-  var prec = this.type.binop;
-  if (prec != null && (!noIn || this.type !== types._in)) {
-    if (prec > minPrec) {
-      var logical = this.type === types.logicalOR || this.type === types.logicalAND;
-      var op = this.value;
-      this.next();
-      var startPos = this.start, startLoc = this.startLoc;
-      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
-      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
-      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
-    }
-  }
-  return left
-};
+			return this._linesToString(['  int channel = int(integerMod(index, 4.0))', '  index = float(int(index) / 4)']);
+		}
 
-pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
-  var node = this.startNodeAt(startPos, startLoc);
-  node.left = left;
-  node.operator = op;
-  node.right = right;
-  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetTextureIndexString
+   *
+   * @desc Get generic texture index string, if floatTextures flag is true.
+   *
+   * @example
+   * '  index = float(int(index)/4);\n'
+   *
+   */
 
-// Parse unary operators, both prefix and postfix.
+	}, {
+		key: '_getGetTextureIndexString',
+		value: function _getGetTextureIndexString() {
+			return this.floatTextures ? '  index = float(int(index)/4);\n' : '';
+		}
 
-pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
-  var this$1 = this;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetResultString
+   *
+   */
 
-  var startPos = this.start, startLoc = this.startLoc, expr;
-  if (this.inAsync && this.isContextual("await")) {
-    expr = this.parseAwait();
-    sawUnary = true;
-  } else if (this.type.prefix) {
-    var node = this.startNode(), update = this.type === types.incDec;
-    node.operator = this.value;
-    node.prefix = true;
-    this.next();
-    node.argument = this.parseMaybeUnary(null, true);
-    this.checkExpressionErrors(refDestructuringErrors, true);
-    if (update) { this.checkLVal(node.argument); }
-    else if (this.strict && node.operator === "delete" &&
-             node.argument.type === "Identifier")
-      { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
-    else { sawUnary = true; }
-    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-  } else {
-    expr = this.parseExprSubscripts(refDestructuringErrors);
-    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-    while (this.type.postfix && !this.canInsertSemicolon()) {
-      var node$1 = this$1.startNodeAt(startPos, startLoc);
-      node$1.operator = this$1.value;
-      node$1.prefix = false;
-      node$1.argument = expr;
-      this$1.checkLVal(expr);
-      this$1.next();
-      expr = this$1.finishNode(node$1, "UpdateExpression");
-    }
-  }
+	}, {
+		key: '_getGetResultString',
+		value: function _getGetResultString() {
+			if (!this.floatTextures) return '  return decode32(texel);\n';
+			return this._linesToString(['  if (channel == 0) return texel.r', '  if (channel == 1) return texel.g', '  if (channel == 2) return texel.b', '  if (channel == 3) return texel.a']);
+		}
 
-  if (!sawUnary && this.eat(types.starstar))
-    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
-  else
-    { return expr }
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainParamsString
+   *
+   * @desc Generate transpiled glsl Strings for user-defined parameters sent to a kernel
+   *
+   * @param {Array} args - The actual parameters sent to the Kernel
+   *
+   * @returns {String} result
+   *
+   */
 
-// Parse call, dot, and `[]`-subscript expressions.
+	}, {
+		key: '_getMainParamsString',
+		value: function _getMainParamsString(args) {
+			var result = [];
+			var paramTypes = this.paramTypes;
+			var paramNames = this.paramNames;
+			for (var i = 0; i < paramNames.length; i++) {
+				var param = args[i];
+				var paramName = paramNames[i];
+				var paramType = paramTypes[i];
+				if (this.hardcodeConstants) {
+					if (paramType === 'Array' || paramType === 'Texture') {
+						var paramDim = utils.getDimensions(param, true);
+						var paramSize = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, paramDim);
 
-pp$3.parseExprSubscripts = function(refDestructuringErrors) {
-  var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseExprAtom(refDestructuringErrors);
-  var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")";
-  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }
-  var result = this.parseSubscripts(expr, startPos, startLoc);
-  if (refDestructuringErrors && result.type === "MemberExpression") {
-    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
-    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
-  }
-  return result
-};
+						result.push('uniform highp sampler2D user_' + paramName, 'highp vec2 user_' + paramName + 'Size = vec2(' + paramSize[0] + '.0, ' + paramSize[1] + '.0)', 'highp vec3 user_' + paramName + 'Dim = vec3(' + paramDim[0] + '.0, ' + paramDim[1] + '.0, ' + paramDim[2] + '.0)');
+					} else if (paramType === 'Number' && Number.isInteger(param)) {
+						result.push('highp float user_' + paramName + ' = ' + param + '.0');
+					} else if (paramType === 'Number') {
+						result.push('highp float user_' + paramName + ' = ' + param);
+					}
+				} else {
+					if (paramType === 'Array' || paramType === 'Texture' || paramType === 'Input') {
+						result.push('uniform highp sampler2D user_' + paramName, 'uniform highp vec2 user_' + paramName + 'Size', 'uniform highp vec3 user_' + paramName + 'Dim');
+					} else if (paramType === 'Number') {
+						result.push('uniform highp float user_' + paramName);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
 
-pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
-  var this$1 = this;
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainConstantsString
+   *
+   */
 
-  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
-      this.lastTokEnd == base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
-  for (var computed = (void 0);;) {
-    if ((computed = this$1.eat(types.bracketL)) || this$1.eat(types.dot)) {
-      var node = this$1.startNodeAt(startPos, startLoc);
-      node.object = base;
-      node.property = computed ? this$1.parseExpression() : this$1.parseIdent(true);
-      node.computed = !!computed;
-      if (computed) { this$1.expect(types.bracketR); }
-      base = this$1.finishNode(node, "MemberExpression");
-    } else if (!noCalls && this$1.eat(types.parenL)) {
-      var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this$1.yieldPos, oldAwaitPos = this$1.awaitPos;
-      this$1.yieldPos = 0;
-      this$1.awaitPos = 0;
-      var exprList = this$1.parseExprList(types.parenR, this$1.options.ecmaVersion >= 8, false, refDestructuringErrors);
-      if (maybeAsyncArrow && !this$1.canInsertSemicolon() && this$1.eat(types.arrow)) {
-        this$1.checkPatternErrors(refDestructuringErrors, false);
-        this$1.checkYieldAwaitInDefaultParams();
-        this$1.yieldPos = oldYieldPos;
-        this$1.awaitPos = oldAwaitPos;
-        return this$1.parseArrowExpression(this$1.startNodeAt(startPos, startLoc), exprList, true)
-      }
-      this$1.checkExpressionErrors(refDestructuringErrors, true);
-      this$1.yieldPos = oldYieldPos || this$1.yieldPos;
-      this$1.awaitPos = oldAwaitPos || this$1.awaitPos;
-      var node$1 = this$1.startNodeAt(startPos, startLoc);
-      node$1.callee = base;
-      node$1.arguments = exprList;
-      base = this$1.finishNode(node$1, "CallExpression");
-    } else if (this$1.type === types.backQuote) {
-      var node$2 = this$1.startNodeAt(startPos, startLoc);
-      node$2.tag = base;
-      node$2.quasi = this$1.parseTemplate({isTagged: true});
-      base = this$1.finishNode(node$2, "TaggedTemplateExpression");
-    } else {
-      return base
-    }
-  }
-};
+	}, {
+		key: '_getMainConstantsString',
+		value: function _getMainConstantsString() {
+			var result = [];
+			if (this.constants) {
+				for (var name in this.constants) {
+					if (!this.constants.hasOwnProperty(name)) continue;
+					var value = parseFloat(this.constants[name]);
 
-// Parse an atomic expression — either a single token that is an
-// expression, an expression started by a keyword like `function` or
-// `new`, or an expression wrapped in punctuation like `()`, `[]`,
-// or `{}`.
+					if (Number.isInteger(value)) {
+						result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
+					} else {
+						result.push('const float constants_' + name + ' = ' + parseFloat(value));
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
 
-pp$3.parseExprAtom = function(refDestructuringErrors) {
-  var node, canBeArrow = this.potentialArrowAt == this.start;
-  switch (this.type) {
-  case types._super:
-    if (!this.inFunction)
-      { this.raise(this.start, "'super' outside of function or class"); }
-    node = this.startNode();
-    this.next();
-    // The `super` keyword can appear at below:
-    // SuperProperty:
-    //     super [ Expression ]
-    //     super . IdentifierName
-    // SuperCall:
-    //     super Arguments
-    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
-      { this.unexpected(); }
-    return this.finishNode(node, "Super")
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getKernelString
+   *
+   * @desc Get Kernel program string (in *glsl*) for a kernel.
+   *
+   * @returns {String} result
+   *
+   */
 
-  case types._this:
-    node = this.startNode();
-    this.next();
-    return this.finishNode(node, "ThisExpression")
+	}, {
+		key: '_getKernelString',
+		value: function _getKernelString() {
+			var result = [];
+			var names = this.subKernelOutputVariableNames;
+			if (names !== null) {
+				result.push('highp float kernelResult = 0.0');
+				for (var i = 0; i < names.length; i++) {
+					result.push('highp float ' + names[i] + ' = 0.0');
+				}
 
-  case types.name:
-    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
-    var id = this.parseIdent(this.type !== types.name);
-    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
-      { return this.parseFunction(this.startNodeAt(startPos, startLoc), false, false, true) }
-    if (canBeArrow && !this.canInsertSemicolon()) {
-      if (this.eat(types.arrow))
-        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
-      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
-        id = this.parseIdent();
-        if (this.canInsertSemicolon() || !this.eat(types.arrow))
-          { this.unexpected(); }
-        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
-      }
-    }
-    return id
+				/* this is v2 prep
+       result.push('highp float kernelResult = 0.0');
+    result.push('layout(location = 0) out highp float fradData0 = 0.0');
+    for (let i = 0; i < names.length; i++) {
+    	result.push(
+           `highp float ${ names[i] } = 0.0`,
+    	  `layout(location = ${ i + 1 }) out highp float fragData${ i + 1 } = 0.0`
+         );
+    }*/
+			} else {
+				result.push('highp float kernelResult = 0.0');
+			}
 
-  case types.regexp:
-    var value = this.value;
-    node = this.parseLiteral(value.value);
-    node.regex = {pattern: value.pattern, flags: value.flags};
-    return node
+			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+		}
 
-  case types.num: case types.string:
-    return this.parseLiteral(this.value)
+		/**
+   *
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainResultString
+   *
+   * @desc Get main result string with checks for floatOutput, graphical, subKernelsOutputs, etc.
+   *
+   * @returns {String} result
+   *
+   */
 
-  case types._null: case types._true: case types._false:
-    node = this.startNode();
-    node.value = this.type === types._null ? null : this.type === types._true;
-    node.raw = this.type.keyword;
-    this.next();
-    return this.finishNode(node, "Literal")
+	}, {
+		key: '_getMainResultString',
+		value: function _getMainResultString() {
+			var names = this.subKernelOutputVariableNames;
+			var result = [];
 
-  case types.parenL:
-    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
-    if (refDestructuringErrors) {
-      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
-        { refDestructuringErrors.parenthesizedAssign = start; }
-      if (refDestructuringErrors.parenthesizedBind < 0)
-        { refDestructuringErrors.parenthesizedBind = start; }
-    }
-    return expr
+			if (this.floatOutput) {
+				result.push('  index *= 4.0');
+			}
 
-  case types.bracketL:
-    node = this.startNode();
-    this.next();
-    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
-    return this.finishNode(node, "ArrayExpression")
+			if (this.graphical) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = actualColor');
+			} else if (this.floatOutput) {
+				var channels = ['r', 'g', 'b', 'a'];
 
-  case types.braceL:
-    return this.parseObj(false, refDestructuringErrors)
+				for (var i = 0; i < channels.length; ++i) {
+					result.push('  threadId = indexTo3D(index, uOutputDim)');
+					result.push('  kernel()');
 
-  case types._function:
-    node = this.startNode();
-    this.next();
-    return this.parseFunction(node, false)
+					if (names) {
+						result.push('  gl_FragData[0].' + channels[i] + ' = kernelResult');
 
-  case types._class:
-    return this.parseClass(this.startNode(), false)
+						for (var j = 0; j < names.length; ++j) {
+							result.push('  gl_FragData[' + (j + 1) + '].' + channels[i] + ' = ' + names[j]);
+						}
+					} else {
+						result.push('  gl_FragColor.' + channels[i] + ' = kernelResult');
+					}
 
-  case types._new:
-    return this.parseNew()
+					if (i < channels.length - 1) {
+						result.push('  index += 1.0');
+					}
+				}
+			} else if (names !== null) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)');
+				result.push('  kernel()');
+				result.push('  gl_FragData[0] = encode32(kernelResult)');
+				for (var _i3 = 0; _i3 < names.length; _i3++) {
+					result.push('  gl_FragData[' + (_i3 + 1) + '] = encode32(' + names[_i3] + ')');
+				}
+			} else {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = encode32(kernelResult)');
+			}
 
-  case types.backQuote:
-    return this.parseTemplate()
+			return this._linesToString(result);
+		}
 
-  default:
-    this.unexpected();
-  }
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _linesToString
+   *
+   * @param {Array} lines - An Array of strings
+   *
+   * @returns {String} Single combined String, seperated by *\n*
+   *
+   */
 
-pp$3.parseLiteral = function(value) {
-  var node = this.startNode();
-  node.value = value;
-  node.raw = this.input.slice(this.start, this.end);
-  this.next();
-  return this.finishNode(node, "Literal")
-};
+	}, {
+		key: '_linesToString',
+		value: function _linesToString(lines) {
+			if (lines.length > 0) {
+				return lines.join(';\n') + ';\n';
+			} else {
+				return '\n';
+			}
+		}
 
-pp$3.parseParenExpression = function() {
-  this.expect(types.parenL);
-  var val = this.parseExpression();
-  this.expect(types.parenR);
-  return val
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _replaceArtifacts
+   *
+   * @param {String} src - Shader string
+   * @param {Array} map - Variables/Constants associated with shader
+   *
+   */
 
-pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
-  var this$1 = this;
+	}, {
+		key: '_replaceArtifacts',
+		value: function _replaceArtifacts(src, map) {
+			return src.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z])*)__;\n/g, function (match, artifact) {
+				if (map.hasOwnProperty(artifact)) {
+					return map[artifact];
+				}
+				throw 'unhandled artifact ' + artifact;
+			});
+		}
 
-  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
-  if (this.options.ecmaVersion >= 6) {
-    this.next();
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _addKernels
+   *
+   * @desc Adds all the sub-kernels supplied with this Kernel instance.
+   *
+   */
 
-    var innerStartPos = this.start, innerStartLoc = this.startLoc;
-    var exprList = [], first = true, lastIsComma = false;
-    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
-    this.yieldPos = 0;
-    this.awaitPos = 0;
-    while (this.type !== types.parenR) {
-      first ? first = false : this$1.expect(types.comma);
-      if (allowTrailingComma && this$1.afterTrailingComma(types.parenR, true)) {
-        lastIsComma = true;
-        break
-      } else if (this$1.type === types.ellipsis) {
-        spreadStart = this$1.start;
-        exprList.push(this$1.parseParenItem(this$1.parseRestBinding()));
-        if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
-        break
-      } else {
-        exprList.push(this$1.parseMaybeAssign(false, refDestructuringErrors, this$1.parseParenItem));
-      }
-    }
-    var innerEndPos = this.start, innerEndLoc = this.startLoc;
-    this.expect(types.parenR);
+	}, {
+		key: '_addKernels',
+		value: function _addKernels() {
+			var builder = this.functionBuilder;
+			var gl = this._webGl;
 
-    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
-      this.checkPatternErrors(refDestructuringErrors, false);
-      this.checkYieldAwaitInDefaultParams();
-      this.yieldPos = oldYieldPos;
-      this.awaitPos = oldAwaitPos;
-      return this.parseParenArrowList(startPos, startLoc, exprList)
-    }
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+			builder.addNativeFunctions(this.nativeFunctions);
 
-    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
-    if (spreadStart) { this.unexpected(spreadStart); }
-    this.checkExpressionErrors(refDestructuringErrors, true);
-    this.yieldPos = oldYieldPos || this.yieldPos;
-    this.awaitPos = oldAwaitPos || this.awaitPos;
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations
+			}, this.paramNames, this.paramTypes);
 
-    if (exprList.length > 1) {
-      val = this.startNodeAt(innerStartPos, innerStartLoc);
-      val.expressions = exprList;
-      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
-    } else {
-      val = exprList[0];
-    }
-  } else {
-    val = this.parseParenExpression();
-  }
+			if (this.subKernels !== null) {
+				var ext = this.ext = gl.getExtension('WEBGL_draw_buffers');
+				if (!ext) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				for (var i = 0; i < this.subKernels.length; i++) {
+					var subKernel = this.subKernels[i];
+					builder.addSubKernel(subKernel, {
+						prototypeOnly: false,
+						constants: this.constants,
+						output: this.output,
+						debug: this.debug,
+						loopMaxIterations: this.loopMaxIterations
+					});
+					this.subKernelOutputTextures.push(this.getSubKernelTexture(i));
+					this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
+				}
+			} else if (this.subKernelProperties !== null) {
+				var _ext = this.ext = gl.getExtension('WEBGL_draw_buffers');
+				if (!_ext) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				var _i4 = 0;
+				for (var p in this.subKernelProperties) {
+					if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+					var _subKernel = this.subKernelProperties[p];
+					builder.addSubKernel(_subKernel, {
+						prototypeOnly: false,
+						constants: this.constants,
+						output: this.output,
+						debug: this.debug,
+						loopMaxIterations: this.loopMaxIterations
+					});
+					this.subKernelOutputTextures.push(this.getSubKernelTexture(p));
+					this.subKernelOutputVariableNames.push(_subKernel.name + 'Result');
+					_i4++;
+				}
+			}
+		}
 
-  if (this.options.preserveParens) {
-    var par = this.startNodeAt(startPos, startLoc);
-    par.expression = val;
-    return this.finishNode(par, "ParenthesizedExpression")
-  } else {
-    return val
-  }
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getFragShaderString
+   *
+   * @desc Get the fragment shader String.
+   * If the String hasn't been compiled yet,
+   * then this method compiles it as well
+   *
+   * @param {Array} args - The actual parameters sent to the Kernel
+   *
+   * @returns {String} Fragment Shader string
+   *
+   */
 
-pp$3.parseParenItem = function(item) {
-  return item
-};
+	}, {
+		key: '_getFragShaderString',
+		value: function _getFragShaderString(args) {
+			if (this.compiledFragShaderString !== null) {
+				return this.compiledFragShaderString;
+			}
+			return this.compiledFragShaderString = this._replaceArtifacts(fragShaderString, this._getFragShaderArtifactMap(args));
+		}
 
-pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
-  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
-};
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getVertShaderString
+   *
+   * @desc Get the vertical shader String
+   *
+   * @param {Array} args - The actual parameters sent to the Kernel
+   *
+   * @returns {String} Vertical Shader string
+   *
+   */
 
-// New's precedence is slightly tricky. It must allow its argument to
-// be a `[]` or dot subscript expression, but not a call — at least,
-// not without wrapping it in parentheses. Thus, it uses the noCalls
-// argument to parseSubscripts to prevent it from consuming the
-// argument list.
+	}, {
+		key: '_getVertShaderString',
+		value: function _getVertShaderString(args) {
+			if (this.compiledVertShaderString !== null) {
+				return this.compiledVertShaderString;
+			}
+			//TODO: webgl2 compile like frag shader
+			return this.compiledVertShaderString = vertShaderString;
+		}
 
-var empty$1 = [];
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name toString
+   *
+   * @desc Returns the *pre-compiled* Kernel as a JS Object String, that can be reused.
+   *
+   */
 
-pp$3.parseNew = function() {
-  var node = this.startNode();
-  var meta = this.parseIdent(true);
-  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
-    node.meta = meta;
-    var containsEsc = this.containsEsc;
-    node.property = this.parseIdent(true);
-    if (node.property.name !== "target" || containsEsc)
-      { this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
-    if (!this.inFunction)
-      { this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
-    return this.finishNode(node, "MetaProperty")
-  }
-  var startPos = this.start, startLoc = this.startLoc;
-  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
-  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }
-  else { node.arguments = empty$1; }
-  return this.finishNode(node, "NewExpression")
-};
+	}, {
+		key: 'toString',
+		value: function toString() {
+			return kernelString(this);
+		}
+	}, {
+		key: 'addFunction',
+		value: function addFunction(fn) {
+			this.functionBuilder.addFunction(null, fn);
+		}
+	}]);
 
-// Parse template expression.
+	return WebGLKernel;
+}(KernelBase);
+},{"../../core/texture":73,"../../core/utils":75,"../kernel-base":58,"./kernel-string":63,"./shader-frag":66,"./shader-vert":67}],65:[function(require,module,exports){
+'use strict';
 
-pp$3.parseTemplateElement = function(ref) {
-  var isTagged = ref.isTagged;
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-  var elem = this.startNode();
-  if (this.type === types.invalidTemplate) {
-    if (!isTagged) {
-      this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
-    }
-    elem.value = {
-      raw: this.value,
-      cooked: null
-    };
-  } else {
-    elem.value = {
-      raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
-      cooked: this.value
-    };
-  }
-  this.next();
-  elem.tail = this.type === types.backQuote;
-  return this.finishNode(elem, "TemplateElement")
-};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-pp$3.parseTemplate = function(ref) {
-  var this$1 = this;
-  if ( ref === void 0 ) ref = {};
-  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-  var node = this.startNode();
-  this.next();
-  node.expressions = [];
-  var curElt = this.parseTemplateElement({isTagged: isTagged});
-  node.quasis = [curElt];
-  while (!curElt.tail) {
-    this$1.expect(types.dollarBraceL);
-    node.expressions.push(this$1.parseExpression());
-    this$1.expect(types.braceR);
-    node.quasis.push(curElt = this$1.parseTemplateElement({isTagged: isTagged}));
-  }
-  this.next();
-  return this.finishNode(node, "TemplateLiteral")
-};
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-pp$3.isAsyncProp = function(prop) {
-  return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
-    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword) &&
-    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
-};
+var RunnerBase = require('../runner-base');
+var WebGLKernel = require('./kernel');
+var utils = require('../../core/utils');
+var WebGLFunctionBuilder = require('./function-builder');
 
-// Parse an object literal or binding pattern.
+module.exports = function (_RunnerBase) {
+	_inherits(WebGLRunner, _RunnerBase);
 
-pp$3.parseObj = function(isPattern, refDestructuringErrors) {
-  var this$1 = this;
+	/**
+  * @constructor WebGLRunner
+  *
+ 	 * @extends RunnerBase
+  	 * @desc Instantiates a Runner instance for the kernel.
+  * 
+  * @param {Object} settings - Settings to instantiate properties in RunnerBase, with given values
+  *
+  */
+	function WebGLRunner(settings) {
+		_classCallCheck(this, WebGLRunner);
 
-  var node = this.startNode(), first = true, propHash = {};
-  node.properties = [];
-  this.next();
-  while (!this.eat(types.braceR)) {
-    if (!first) {
-      this$1.expect(types.comma);
-      if (this$1.afterTrailingComma(types.braceR)) { break }
-    } else { first = false; }
+		var _this = _possibleConstructorReturn(this, (WebGLRunner.__proto__ || Object.getPrototypeOf(WebGLRunner)).call(this, new WebGLFunctionBuilder(), settings));
 
-    var prop = this$1.parseProperty(isPattern, refDestructuringErrors);
-    if (!isPattern) { this$1.checkPropClash(prop, propHash, refDestructuringErrors); }
-    node.properties.push(prop);
-  }
-  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
-};
+		_this.Kernel = WebGLKernel;
+		_this.kernel = null;
+		return _this;
+	}
 
-pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
-  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
-  if (this.options.ecmaVersion >= 6) {
-    prop.method = false;
-    prop.shorthand = false;
-    if (isPattern || refDestructuringErrors) {
-      startPos = this.start;
-      startLoc = this.startLoc;
-    }
-    if (!isPattern)
-      { isGenerator = this.eat(types.star); }
-  }
-  var containsEsc = this.containsEsc;
-  this.parsePropertyName(prop);
-  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
-    isAsync = true;
-    this.parsePropertyName(prop, refDestructuringErrors);
-  } else {
-    isAsync = false;
-  }
-  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
-  return this.finishNode(prop, "Property")
-};
+	/**
+  * @memberOf WebGLRunner#
+  * @function
+  * @name getMode
+  *
+  * @desc Return the current mode in which gpu.js is executing.
+  * 
+  * @returns {String} The current mode; "cpu".
+  *
+  */
 
-pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
-  if ((isGenerator || isAsync) && this.type === types.colon)
-    { this.unexpected(); }
 
-  if (this.eat(types.colon)) {
-    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
-    prop.kind = "init";
-  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
-    if (isPattern) { this.unexpected(); }
-    prop.kind = "init";
-    prop.method = true;
-    prop.value = this.parseMethod(isGenerator, isAsync);
-  } else if (!isPattern && !containsEsc &&
-             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
-             (prop.key.name === "get" || prop.key.name === "set") &&
-             (this.type != types.comma && this.type != types.braceR)) {
-    if (isGenerator || isAsync) { this.unexpected(); }
-    prop.kind = prop.key.name;
-    this.parsePropertyName(prop);
-    prop.value = this.parseMethod(false);
-    var paramCount = prop.kind === "get" ? 0 : 1;
-    if (prop.value.params.length !== paramCount) {
-      var start = prop.value.start;
-      if (prop.kind === "get")
-        { this.raiseRecoverable(start, "getter should have no params"); }
-      else
-        { this.raiseRecoverable(start, "setter should have exactly one param"); }
-    } else {
-      if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
-        { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
-    }
-  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-    this.checkUnreserved(prop.key);
-    prop.kind = "init";
-    if (isPattern) {
-      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
-    } else if (this.type === types.eq && refDestructuringErrors) {
-      if (refDestructuringErrors.shorthandAssign < 0)
-        { refDestructuringErrors.shorthandAssign = this.start; }
-      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
-    } else {
-      prop.value = prop.key;
-    }
-    prop.shorthand = true;
-  } else { this.unexpected(); }
-};
+	_createClass(WebGLRunner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'gpu';
+		}
+	}]);
 
-pp$3.parsePropertyName = function(prop) {
-  if (this.options.ecmaVersion >= 6) {
-    if (this.eat(types.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseMaybeAssign();
-      this.expect(types.bracketR);
-      return prop.key
-    } else {
-      prop.computed = false;
-    }
-  }
-  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(true)
-};
+	return WebGLRunner;
+}(RunnerBase);
+},{"../../core/utils":75,"../runner-base":60,"./function-builder":61,"./kernel":64}],66:[function(require,module,exports){
+"use strict";
 
-// Initialize empty function node.
+module.exports = "__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n#define EPSILON 0.0000001;\n\n__CONSTANTS__;\n\nvarying highp vec2 vTexCoord;\n\nvec4 round(vec4 x) {\n  return floor(x + 0.5);\n}\n\nhighp float round(highp float x) {\n  return floor(x + 0.5);\n}\n\nvec2 integerMod(vec2 x, float y) {\n  vec2 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec3 integerMod(vec3 x, float y) {\n  vec3 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec4 integerMod(vec4 x, vec4 y) {\n  vec4 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nhighp float integerMod(highp float x, highp float y) {\n  highp float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nhighp int integerMod(highp int x, highp int y) {\n  return int(integerMod(float(x), float(y)));\n}\n\n// Here be dragons!\n// DO NOT OPTIMIZE THIS CODE\n// YOU WILL BREAK SOMETHING ON SOMEBODY'S MACHINE\n// LEAVE IT AS IT IS, LEST YOU WASTE YOUR OWN TIME\nconst vec2 MAGIC_VEC = vec2(1.0, -256.0);\nconst vec4 SCALE_FACTOR = vec4(1.0, 256.0, 65536.0, 0.0);\nconst vec4 SCALE_FACTOR_INV = vec4(1.0, 0.00390625, 0.0000152587890625, 0.0); // 1, 1/256, 1/65536\nhighp float decode32(highp vec4 rgba) {\n  __DECODE32_ENDIANNESS__;\n  rgba *= 255.0;\n  vec2 gte128;\n  gte128.x = rgba.b >= 128.0 ? 1.0 : 0.0;\n  gte128.y = rgba.a >= 128.0 ? 1.0 : 0.0;\n  float exponent = 2.0 * rgba.a - 127.0 + dot(gte128, MAGIC_VEC);\n  float res = exp2(round(exponent));\n  rgba.b = rgba.b - 128.0 * gte128.x;\n  res = dot(rgba, SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;\n  res *= gte128.y * -2.0 + 1.0;\n  return res;\n}\n\nhighp vec4 encode32(highp float f) {\n  highp float F = abs(f);\n  highp float sign = f < 0.0 ? 1.0 : 0.0;\n  highp float exponent = floor(log2(F));\n  highp float mantissa = (exp2(-exponent) * F);\n  // exponent += floor(log2(mantissa));\n  vec4 rgba = vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;\n  rgba.rg = integerMod(rgba.rg, 256.0);\n  rgba.b = integerMod(rgba.b, 128.0);\n  rgba.a = exponent*0.5 + 63.5;\n  rgba.ba += vec2(integerMod(exponent+127.0, 2.0), sign) * 128.0;\n  rgba = floor(rgba);\n  rgba *= 0.003921569; // 1/255\n  __ENCODE32_ENDIANNESS__;\n  return rgba;\n}\n// Dragons end here\n\nhighp float index;\nhighp vec3 threadId;\n\nhighp vec3 indexTo3D(highp float idx, highp vec3 texDim) {\n  highp float z = floor(idx / (texDim.x * texDim.y));\n  idx -= z * texDim.x * texDim.y;\n  highp float y = floor(idx / texDim.x);\n  highp float x = integerMod(idx, texDim.x);\n  return vec3(x, y, z);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float z, highp float y, highp float x) {\n  highp vec3 xyz = vec3(x, y, z);\n  xyz = floor(xyz + 0.5);\n  __GET_WRAPAROUND__;\n  highp float index = round(xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z));\n  __GET_TEXTURE_CHANNEL__;\n  highp float w = round(texSize.x);\n  vec2 st = vec2(integerMod(index, w), float(int(index) / int(w))) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  highp vec4 texel = texture2D(tex, st / texSize);\n  __GET_RESULT__;\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float y, highp float x) {\n  return get(tex, texSize, texDim, 0.0, y, x);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float x) {\n  return get(tex, texSize, texDim, 0.0, 0.0, x);\n}\n\nhighp vec4 actualColor;\nvoid color(float r, float g, float b, float a) {\n  actualColor = vec4(r,g,b,a);\n}\n\nvoid color(float r, float g, float b) {\n  color(r,g,b,1.0);\n}\n\n__MAIN_PARAMS__;\n__MAIN_CONSTANTS__;\n__KERNEL__;\n\nvoid main(void) {\n  index = floor(vTexCoord.s * float(uTexSize.x)) + floor(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
+},{}],67:[function(require,module,exports){
+"use strict";
 
-pp$3.initFunction = function(node) {
-  node.id = null;
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = false;
-    node.expression = false;
-  }
-  if (this.options.ecmaVersion >= 8)
-    { node.async = false; }
-};
+module.exports = "precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nattribute highp vec2 aPos;\nattribute highp vec2 aTexCoord;\n\nvarying highp vec2 vTexCoord;\nuniform vec2 ratio;\n\nvoid main(void) {\n  gl_Position = vec4((aPos + vec2(1)) * ratio + vec2(-1), 0, 1);\n  vTexCoord = aTexCoord;\n}";
+},{}],68:[function(require,module,exports){
+'use strict';
 
-// Parse object or class method.
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-pp$3.parseMethod = function(isGenerator, isAsync) {
-  var node = this.startNode(), oldInGen = this.inGenerator, oldInAsync = this.inAsync,
-      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  this.initFunction(node);
-  if (this.options.ecmaVersion >= 6)
-    { node.generator = isGenerator; }
-  if (this.options.ecmaVersion >= 8)
-    { node.async = !!isAsync; }
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-  this.inGenerator = node.generator;
-  this.inAsync = node.async;
-  this.yieldPos = 0;
-  this.awaitPos = 0;
-  this.inFunction = true;
-  this.enterFunctionScope();
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-  this.expect(types.parenL);
-  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
-  this.checkYieldAwaitInDefaultParams();
-  this.parseFunctionBody(node, false);
+var WebGLKernel = require('./kernel');
+var utils = require('../../core/utils');
 
-  this.inGenerator = oldInGen;
-  this.inAsync = oldInAsync;
-  this.yieldPos = oldYieldPos;
-  this.awaitPos = oldAwaitPos;
-  this.inFunction = oldInFunc;
-  return this.finishNode(node, "FunctionExpression")
-};
+/**
+ * @class WebGLValidatorKernel
+ *
+ * @desc Helper class for WebGLKernel to validate texture size and dimensions.
+ *
+ */
+module.exports = function (_WebGLKernel) {
+	_inherits(WebGLValidatorKernel, _WebGLKernel);
 
-// Parse arrow function expression with given parameters.
+	function WebGLValidatorKernel() {
+		_classCallCheck(this, WebGLValidatorKernel);
 
-pp$3.parseArrowExpression = function(node, params, isAsync) {
-  var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
-      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
+		return _possibleConstructorReturn(this, (WebGLValidatorKernel.__proto__ || Object.getPrototypeOf(WebGLValidatorKernel)).apply(this, arguments));
+	}
 
-  this.enterFunctionScope();
-  this.initFunction(node);
-  if (this.options.ecmaVersion >= 8)
-    { node.async = !!isAsync; }
+	_createClass(WebGLValidatorKernel, [{
+		key: 'validateOptions',
 
-  this.inGenerator = false;
-  this.inAsync = node.async;
-  this.yieldPos = 0;
-  this.awaitPos = 0;
-  this.inFunction = true;
 
-  node.params = this.toAssignableList(params, true);
-  this.parseFunctionBody(node, true);
+		/** 
+   * @memberOf WebGLValidatorKernel#
+   * @function
+   * @name validateOptions
+   *
+   */
+		value: function validateOptions() {
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+		}
+	}]);
 
-  this.inGenerator = oldInGen;
-  this.inAsync = oldInAsync;
-  this.yieldPos = oldYieldPos;
-  this.awaitPos = oldAwaitPos;
-  this.inFunction = oldInFunc;
-  return this.finishNode(node, "ArrowFunctionExpression")
+	return WebGLValidatorKernel;
+}(WebGLKernel);
+},{"../../core/utils":75,"./kernel":64}],69:[function(require,module,exports){
+'use strict';
+
+var utils = require('./utils');
+module.exports = function alias(name, fn) {
+	var fnString = fn.toString();
+	return new Function('return function ' + name + ' (' + utils.getParamNamesFromString(fnString).join(', ') + ') {' + utils.getFunctionBodyFromString(fnString) + '}')();
 };
+},{"./utils":75}],70:[function(require,module,exports){
+'use strict';
 
-// Parse function body and check parameters.
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-pp$3.parseFunctionBody = function(node, isArrowFunction) {
-  var isExpression = isArrowFunction && this.type !== types.braceL;
-  var oldStrict = this.strict, useStrict = false;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  if (isExpression) {
-    node.body = this.parseMaybeAssign();
-    node.expression = true;
-    this.checkParams(node, false);
-  } else {
-    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
-    if (!oldStrict || nonSimple) {
-      useStrict = this.strictDirective(this.end);
-      // If this is a strict mode function, verify that argument names
-      // are not repeated, and it does not try to bind the words `eval`
-      // or `arguments`.
-      if (useStrict && nonSimple)
-        { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
-    }
-    // Start a new scope with regard to labels and the `inFunction`
-    // flag (restore them to their old value afterwards).
-    var oldLabels = this.labels;
-    this.labels = [];
-    if (useStrict) { this.strict = true; }
+var UtilsCore = require("./utils-core");
 
-    // Add the params to varDeclaredNames to ensure that an error is thrown
-    // if a let/const declaration in the function clashes with one of the params.
-    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && this.isSimpleParamList(node.params));
-    node.body = this.parseBlock(false);
-    node.expression = false;
-    this.adaptDirectivePrologue(node.body.body);
-    this.labels = oldLabels;
-  }
-  this.exitFunctionScope();
+/**
+ * This is a minimalistic version of GPU.js used 
+ * to run precompiled GPU.JS code.
+ *
+ * This intentionally excludes the JS AST compiller : which is 400kb alone/
+ *
+ * @class GPUCore
+ */
+module.exports = function () {
+	function GPUCore() {
+		_classCallCheck(this, GPUCore);
+	}
 
-  if (this.strict && node.id) {
-    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
-    this.checkLVal(node.id, "none");
-  }
-  this.strict = oldStrict;
-};
+	_createClass(GPUCore, null, [{
+		key: "validateKernelObj",
+
+
+		/**
+   * @name validateKernelObj
+   * @function
+   * @static
+   * @memberOf GPUCore
+   *
+   * @description Validates the KernelObj to comply with the defined format
+   * Note that this does only a limited sanity check, and does not  
+   * guarantee a full working validation.
+   *
+   * For the kernel object format see : <kernelObj-format>
+   *
+   * @param {Object|String} kernelObj - KernelObj used to validate
+   *
+   * @returns {Object} The validated kernel object, converted from JSON if needed
+   *
+   */
+		value: function validateKernelObj(kernelObj) {
+
+			// NULL validation
+			if (kernelObj === null) {
+				throw "KernelObj being validated is NULL";
+			}
+
+			// String JSON conversion
+			if (typeof kernelObj === "string") {
+				try {
+					kernelObj = JSON.parse(kernelObj);
+				} catch (e) {
+					console.error(e);
+					throw "Failed to convert KernelObj from JSON string";
+				}
 
-pp$3.isSimpleParamList = function(params) {
-  for (var i = 0, list = params; i < list.length; i += 1)
-    {
-    var param = list[i];
+				// NULL validation
+				if (kernelObj === null) {
+					throw "Invalid (NULL) KernelObj JSON string representation";
+				}
+			}
 
-    if (param.type !== "Identifier") { return false
-  } }
-  return true
-};
+			// Check for kernel obj flag
+			if (kernelObj.isKernelObj !== true) {
+				throw "Failed missing isKernelObj flag check";
+			}
 
-// Checks function params for various disallowed patterns such as using "eval"
-// or "arguments" and duplicate parameters.
+			// Return the validated kernelObj
+			return kernelObj;
+		}
 
-pp$3.checkParams = function(node, allowDuplicates) {
-  var this$1 = this;
+		/**
+   * @name loadKernelObj
+   * @function
+   * @static
+   * @memberOf GPUCore
+   *
+   * @description Loads the precompiled kernel object. For GPUCore this is the ONLY way to create the kernel.
+   * To generate the kernelObj use <Kernel.exportKernelObj>
+   *
+   * Note that this function calls <validateKernelObj> internally, and throws an exception if it fails.
+   *
+   * @see GPUCore.validateKernelObj
+   * @see	Kernel.exportKernelObj
+   *
+   * @param {Object} kernelObj - The precompiled kernel object
+   * @param {Object} inOpt - [Optional] the option overrides to use
+   *
+   * @returns {Function} The kernel function
+   * 
+   */
 
-  var nameHash = {};
-  for (var i = 0, list = node.params; i < list.length; i += 1)
-    {
-    var param = list[i];
+	}, {
+		key: "loadKernelObj",
+		value: function loadKernelObj(kernelObj, inOpt) {
 
-    this$1.checkLVal(param, "var", allowDuplicates ? null : nameHash);
-  }
-};
+			// Validates the kernelObj, throws an exception if it fails
+			kernelObj = validateKernelObj(kernelObj);
+		}
+	}]);
 
-// Parses a comma-separated list of expressions, and returns them as
-// an array. `close` is the token type that ends the list, and
-// `allowEmpty` can be turned on to allow subsequent commas with
-// nothing in between them to be parsed as `null` (which is needed
-// for array literals).
+	return GPUCore;
+}();
+},{"./utils-core":74}],71:[function(require,module,exports){
+'use strict';
 
-pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
-  var this$1 = this;
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-  var elts = [], first = true;
-  while (!this.eat(close)) {
-    if (!first) {
-      this$1.expect(types.comma);
-      if (allowTrailingComma && this$1.afterTrailingComma(close)) { break }
-    } else { first = false; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-    var elt = (void 0);
-    if (allowEmpty && this$1.type === types.comma)
-      { elt = null; }
-    else if (this$1.type === types.ellipsis) {
-      elt = this$1.parseSpread(refDestructuringErrors);
-      if (refDestructuringErrors && this$1.type === types.comma && refDestructuringErrors.trailingComma < 0)
-        { refDestructuringErrors.trailingComma = this$1.start; }
-    } else {
-      elt = this$1.parseMaybeAssign(false, refDestructuringErrors);
-    }
-    elts.push(elt);
-  }
-  return elts
-};
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-pp$3.checkUnreserved = function(ref) {
-  var start = ref.start;
-  var end = ref.end;
-  var name = ref.name;
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-  if (this.inGenerator && name === "yield")
-    { this.raiseRecoverable(start, "Can not use 'yield' as identifier inside a generator"); }
-  if (this.inAsync && name === "await")
-    { this.raiseRecoverable(start, "Can not use 'await' as identifier inside an async function"); }
-  if (this.isKeyword(name))
-    { this.raise(start, ("Unexpected keyword '" + name + "'")); }
-  if (this.options.ecmaVersion < 6 &&
-    this.input.slice(start, end).indexOf("\\") != -1) { return }
-  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
-  if (re.test(name)) {
-    if (!this.inAsync && name === "await")
-      { this.raiseRecoverable(start, "Can not use keyword 'await' outside an async function"); }
-    this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
-  }
-};
+var utils = require('./utils');
+var WebGLRunner = require('../backend/web-gl/runner');
+var CPURunner = require('../backend/cpu/runner');
+var WebGLValidatorKernel = require('../backend/web-gl/validator-kernel');
+var GPUCore = require("./gpu-core");
 
-// Parse the next token as an identifier. If `liberal` is true (used
-// when parsing properties), it will also convert keywords into
-// identifiers.
+/**
+ * Initialises the GPU.js library class which manages the webGlContext for the created functions.
+ * @class
+ * @extends GPUCore
+ */
 
-pp$3.parseIdent = function(liberal, isBinding) {
-  var node = this.startNode();
-  if (liberal && this.options.allowReserved == "never") { liberal = false; }
-  if (this.type === types.name) {
-    node.name = this.value;
-  } else if (this.type.keyword) {
-    node.name = this.type.keyword;
+var GPU = function (_GPUCore) {
+	_inherits(GPU, _GPUCore);
 
-    // To fix https://github.com/acornjs/acorn/issues/575
-    // `class` and `function` keywords push new context into this.context.
-    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.
-    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword
-    if ((node.name === "class" || node.name === "function") &&
-        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
-      this.context.pop();
-    }
-  } else {
-    this.unexpected();
-  }
-  this.next();
-  this.finishNode(node, "Identifier");
-  if (!liberal) { this.checkUnreserved(node); }
-  return node
-};
+	/**
+  * Creates an instance of GPU.
+  * @param {any} settings - Settings to set mode, andother properties. See #GPUCore
+  * @memberOf GPU#
+  */
+	function GPU(settings) {
+		_classCallCheck(this, GPU);
 
-// Parses yield expression inside generator.
+		var _this = _possibleConstructorReturn(this, (GPU.__proto__ || Object.getPrototypeOf(GPU)).call(this, settings));
 
-pp$3.parseYield = function() {
-  if (!this.yieldPos) { this.yieldPos = this.start; }
+		settings = settings || {};
+		_this._canvas = settings.canvas || null;
+		_this._webGl = settings.webGl || null;
+		var mode = settings.mode;
+		var detectedMode = void 0;
+		if (!utils.isWebGlSupported()) {
+			if (mode && mode !== 'cpu') {
+				throw new Error('A requested mode of "' + mode + '" and is not supported');
+			} else {
+				console.warn('Warning: gpu not supported, falling back to cpu support');
+				detectedMode = 'cpu';
+			}
+		} else {
+			detectedMode = mode || 'gpu';
+		}
 
-  var node = this.startNode();
-  this.next();
-  if (this.type == types.semi || this.canInsertSemicolon() || (this.type != types.star && !this.type.startsExpr)) {
-    node.delegate = false;
-    node.argument = null;
-  } else {
-    node.delegate = this.eat(types.star);
-    node.argument = this.parseMaybeAssign();
-  }
-  return this.finishNode(node, "YieldExpression")
-};
+		_this.kernels = [];
 
-pp$3.parseAwait = function() {
-  if (!this.awaitPos) { this.awaitPos = this.start; }
+		var runnerSettings = {
+			canvas: _this._canvas,
+			webGl: _this._webGl
+		};
 
-  var node = this.startNode();
-  this.next();
-  node.argument = this.parseMaybeUnary(null, true);
-  return this.finishNode(node, "AwaitExpression")
-};
+		switch (detectedMode) {
+			case 'cpu':
+				_this._runner = new CPURunner(runnerSettings);
+				break;
+			case 'webgl': // for testing
+			case 'gpu':
+				_this._runner = new WebGLRunner(runnerSettings);
+				break;
+			case 'webgl-validator':
+				// for internal
+				_this._runner = new WebGLRunner(runnerSettings);
+				_this._runner.Kernel = WebGLValidatorKernel;
+				break;
+			default:
+				throw new Error('"' + mode + '" mode is not defined');
+		}
+		return _this;
+	}
+	/**
+  *
+  * This creates a callable function object to call the kernel function with the argument parameter set
+  *
+  * @name createKernel
+  * @function
+  * @memberOf GPU##
+  *
+  * @param {Function} fn - The calling to perform the conversion
+  * @param {Object} settings - The parameter configuration object
+  * @property {String} settings.dimensions - Thread dimension array (Defeaults to [1024])
+  * @property {String} settings.mode - CPU / GPU configuration mode (Defaults to null)
+  *
+  * The following modes are supported
+  * *'falsey'* : Attempts to build GPU mode, else fallbacks
+  * *'gpu'* : Attempts to build GPU mode, else fallbacks
+  * *'cpu'* : Forces JS fallback mode only
+  *
+  *
+  * @returns {Function} callable function to run
+  *
+  */
 
-var pp$4 = Parser.prototype;
 
-// This function is used to raise exceptions on parse errors. It
-// takes an offset integer (into the current `input`) to indicate
-// the location of the error, attaches the position to the end
-// of the error message, and then raises a `SyntaxError` with that
-// message.
+	_createClass(GPU, [{
+		key: 'createKernel',
+		value: function createKernel(fn, settings) {
+			//
+			// basic parameters safety checks
+			//
+			if (typeof fn === 'undefined') {
+				throw 'Missing fn parameter';
+			}
+			if (!utils.isFunction(fn) && typeof fn !== 'string') {
+				throw 'fn parameter not a function';
+			}
 
-pp$4.raise = function(pos, message) {
-  var loc = getLineInfo(this.input, pos);
-  message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
-  throw err
-};
+			var kernel = this._runner.buildKernel(fn, settings || {});
 
-pp$4.raiseRecoverable = pp$4.raise;
+			//if canvas didn't come from this, propagate from kernel
+			if (!this._canvas) {
+				this._canvas = kernel.getCanvas();
+			}
+			if (!this._runner.canvas) {
+				this._runner.canvas = kernel.getCanvas();
+			}
 
-pp$4.curPosition = function() {
-  if (this.options.locations) {
-    return new Position(this.curLine, this.pos - this.lineStart)
-  }
-};
+			this.kernels.push(kernel);
 
-var pp$5 = Parser.prototype;
+			return kernel;
+		}
 
-// Object.assign polyfill
-var assign = Object.assign || function(target) {
-  var sources = [], len = arguments.length - 1;
-  while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
+		/**
+   *
+   * Create a super kernel which executes sub kernels
+   * and saves their output to be used with the next sub kernel.
+   * This can be useful if we want to save the output on one kernel,
+   * and then use it as an input to another kernel. *Machine Learning*
+   *
+   * @name createKernelMap
+   * @function
+   * @memberOf GPU#
+   *
+   * @param {Object|Array} subKernels - Sub kernels for this kernel
+   * @param {Function} rootKernel - Root kernel
+   *
+   * @returns {Function} callable kernel function
+   *
+   * @example
+   * const megaKernel = gpu.createKernelMap({
+   *   addResult: function add(a, b) {
+   *     return a[this.thread.x] + b[this.thread.x];
+   *   },
+   *   multiplyResult: function multiply(a, b) {
+   *     return a[this.thread.x] * b[this.thread.x];
+   *   },
+   *  }, function(a, b, c) {
+   *       return multiply(add(a, b), c);
+   * });
+   *
+   * megaKernel(a, b, c);
+   *
+   * Note: You can also define subKernels as an array of functions.
+   * > [add, multiply]
+   *
+   */
 
-  for (var i = 0, list = sources; i < list.length; i += 1) {
-    var source = list[i];
+	}, {
+		key: 'createKernelMap',
+		value: function createKernelMap() {
+			var fn = void 0;
+			var settings = void 0;
+			if (typeof arguments[arguments.length - 2] === 'function') {
+				fn = arguments[arguments.length - 2];
+				settings = arguments[arguments.length - 1];
+			} else {
+				fn = arguments[arguments.length - 1];
+			}
 
-    for (var key in source) {
-      if (has(source, key)) {
-        target[key] = source[key];
-      }
-    }
-  }
-  return target
-};
+			if (!utils.isWebGlDrawBuffersSupported()) {
+				this._runner = new CPURunner(settings);
+			}
 
-// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
+			var kernel = this.createKernel(fn, settings);
+			if (Array.isArray(arguments[0])) {
+				var functions = arguments[0];
+				for (var i = 0; i < functions.length; i++) {
+					kernel.addSubKernel(functions[i]);
+				}
+			} else {
+				var _functions = arguments[0];
+				for (var p in _functions) {
+					if (!_functions.hasOwnProperty(p)) continue;
+					kernel.addSubKernelProperty(p, _functions[p]);
+				}
+			}
 
-pp$5.enterFunctionScope = function() {
-  // var: a hash of var-declared names in the current lexical scope
-  // lexical: a hash of lexically-declared names in the current lexical scope
-  // childVar: a hash of var-declared names in all child lexical scopes of the current lexical scope (within the current function scope)
-  // parentLexical: a hash of lexically-declared names in all parent lexical scopes of the current lexical scope (within the current function scope)
-  this.scopeStack.push({var: {}, lexical: {}, childVar: {}, parentLexical: {}});
-};
+			return kernel;
+		}
 
-pp$5.exitFunctionScope = function() {
-  this.scopeStack.pop();
-};
+		/**
+   *
+   * Combine different kernels into one super Kernel,
+   * useful to perform multiple operations inside one
+   * kernel without the penalty of data transfer between
+   * cpu and gpu.
+   *
+   * The number of kernel functions sent to this method can be variable.
+   * You can send in one, two, etc.
+   *
+   * @name combineKernels
+   * @function
+   * @memberOf GPU#
+   *
+   * @param {Function} subKernels - Kernel function(s) to combine.
+   * @param {Function} rootKernel - Root kernel to combine kernels into
+   *
+   * @example
+   * 	combineKernels(add, multiply, function(a,b,c){
+   *	 	return add(multiply(a,b), c)
+   *	})
+   *
+   * @returns {Function} Callable kernel function
+   *
+   */
 
-pp$5.enterLexicalScope = function() {
-  var parentScope = this.scopeStack[this.scopeStack.length - 1];
-  var childScope = {var: {}, lexical: {}, childVar: {}, parentLexical: {}};
+	}, {
+		key: 'combineKernels',
+		value: function combineKernels() {
+			var lastKernel = arguments[arguments.length - 2];
+			var combinedKernel = arguments[arguments.length - 1];
+			if (this.getMode() === 'cpu') return combinedKernel;
 
-  this.scopeStack.push(childScope);
-  assign(childScope.parentLexical, parentScope.lexical, parentScope.parentLexical);
-};
+			var canvas = arguments[0].getCanvas();
+			var webGl = arguments[0].getWebGl();
 
-pp$5.exitLexicalScope = function() {
-  var childScope = this.scopeStack.pop();
-  var parentScope = this.scopeStack[this.scopeStack.length - 1];
+			for (var i = 0; i < arguments.length - 1; i++) {
+				arguments[i].setCanvas(canvas).setWebGl(webGl).setOutputToTexture(true);
+			}
 
-  assign(parentScope.childVar, childScope.var, childScope.childVar);
-};
+			return function () {
+				combinedKernel.apply(null, arguments);
+				var texSize = lastKernel.texSize;
+				var gl = lastKernel.getWebGl();
+				var threadDim = lastKernel.threadDim;
+				var result = void 0;
+				if (lastKernel.floatOutput) {
+					result = new Float32Array(texSize[0] * texSize[1] * 4);
+					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.FLOAT, result);
+				} else {
+					var bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
+					gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
+					result = new Float32Array(bytes.buffer);
+				}
 
-/**
- * A name can be declared with `var` if there are no variables with the same name declared with `let`/`const`
- * in the current lexical scope or any of the parent lexical scopes in this function.
- */
-pp$5.canDeclareVarName = function(name) {
-  var currentScope = this.scopeStack[this.scopeStack.length - 1];
+				result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
 
-  return !has(currentScope.lexical, name) && !has(currentScope.parentLexical, name)
-};
+				if (lastKernel.output.length === 1) {
+					return result;
+				} else if (lastKernel.output.length === 2) {
+					return utils.splitArray(result, lastKernel.output[0]);
+				} else if (lastKernel.output.length === 3) {
+					var cube = utils.splitArray(result, lastKernel.output[0] * lastKernel.output[1]);
+					return cube.map(function (x) {
+						return utils.splitArray(x, lastKernel.output[0]);
+					});
+				}
+			};
+		}
 
-/**
- * A name can be declared with `let`/`const` if there are no variables with the same name declared with `let`/`const`
- * in the current scope, and there are no variables with the same name declared with `var` in the current scope or in
- * any child lexical scopes in this function.
- */
-pp$5.canDeclareLexicalName = function(name) {
-  var currentScope = this.scopeStack[this.scopeStack.length - 1];
+		/**
+   *
+   * Adds additional functions, that the kernel may call.
+   *
+   * @name addFunction
+   * @function
+   * @memberOf GPU#
+   *
+   * @param {Function|String} fn - JS Function to do conversion
+   * @param {String[]|Object} paramTypes - Parameter type array, assumes all parameters are 'float' if null
+   * @param {String} returnType - The return type, assumes 'float' if null
+   *
+   * @returns {GPU} returns itself
+   *
+   */
 
-  return !has(currentScope.lexical, name) && !has(currentScope.var, name) && !has(currentScope.childVar, name)
-};
+	}, {
+		key: 'addFunction',
+		value: function addFunction(fn, paramTypes, returnType) {
+			this._runner.functionBuilder.addFunction(null, fn, paramTypes, returnType);
+			return this;
+		}
 
-pp$5.declareVarName = function(name) {
-  this.scopeStack[this.scopeStack.length - 1].var[name] = true;
-};
+		/**
+   *
+   * Adds additional native functions, that the kernel may call.
+   *
+   * @name addNativeFunction
+   * @function
+   * @memberOf GPU#
+   *
+   * @param {String} name - native function name, used for reverse lookup
+   * @param {String} nativeFunction - the native function implementation, as it would be defined in it's entirety
+   *
+   * @returns {GPU} returns itself
+   *
+   */
 
-pp$5.declareLexicalName = function(name) {
-  this.scopeStack[this.scopeStack.length - 1].lexical[name] = true;
-};
+	}, {
+		key: 'addNativeFunction',
+		value: function addNativeFunction(name, nativeFunction) {
+			this._runner.functionBuilder.addNativeFunction(name, nativeFunction);
+			return this;
+		}
 
-var Node = function Node(parser, pos, loc) {
-  this.type = "";
-  this.start = pos;
-  this.end = 0;
-  if (parser.options.locations)
-    { this.loc = new SourceLocation(parser, loc); }
-  if (parser.options.directSourceFile)
-    { this.sourceFile = parser.options.directSourceFile; }
-  if (parser.options.ranges)
-    { this.range = [pos, 0]; }
-};
+		/**
+   *
+   * Return the current mode in which gpu.js is executing.
+   * @name getMode
+   * @function
+   * @memberOf GPU#
+   *
+   * @returns {String} The current mode, "cpu", "webgl", etc.
+   *
+   */
 
-// Start an AST node, attaching a start offset.
+	}, {
+		key: 'getMode',
+		value: function getMode() {
+			return this._runner.getMode();
+		}
 
-var pp$6 = Parser.prototype;
+		/**
+   *
+   * Return TRUE, if browser supports WebGl AND Canvas
+   *
+   * @name get isWebGlSupported
+   * @function
+   * @memberOf GPU#
+   *
+   * Note: This function can also be called directly `GPU.isWebGlSupported()`
+   *
+   * @returns {Boolean} TRUE if browser supports webGl
+   *
+   */
 
-pp$6.startNode = function() {
-  return new Node(this, this.start, this.startLoc)
-};
+	}, {
+		key: 'isWebGlSupported',
+		value: function isWebGlSupported() {
+			return utils.isWebGlSupported();
+		}
 
-pp$6.startNodeAt = function(pos, loc) {
-  return new Node(this, pos, loc)
-};
+		/**
+   *
+   * Return the canvas object bound to this gpu instance.
+   *
+   * @name getCanvas
+   * @function
+   * @memberOf GPU#
+   *
+   * @returns {Object} Canvas object if present
+   *
+   */
 
-// Finish an AST node, adding `type` and `end` properties.
+	}, {
+		key: 'getCanvas',
+		value: function getCanvas() {
+			return this._canvas;
+		}
 
-function finishNodeAt(node, type, pos, loc) {
-  node.type = type;
-  node.end = pos;
-  if (this.options.locations)
-    { node.loc.end = loc; }
-  if (this.options.ranges)
-    { node.range[1] = pos; }
-  return node
-}
+		/**
+   *
+   * Return the webGl object bound to this gpu instance.
+   *
+   * @name getWebGl
+   * @function
+   * @memberOf GPU#
+   *
+   * @returns {Object} WebGl object if present
+   *
+   */
 
-pp$6.finishNode = function(node, type) {
-  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
-};
+	}, {
+		key: 'getWebGl',
+		value: function getWebGl() {
+			return this._webGl;
+		}
+	}]);
 
-// Finish node at given position
+	return GPU;
+}(GPUCore);
 
-pp$6.finishNodeAt = function(node, type, pos, loc) {
-  return finishNodeAt.call(this, node, type, pos, loc)
-};
+;
 
-// The algorithm used to determine whether a regexp can appear at a
-// given point in the program is loosely based on sweet.js' approach.
-// See https://github.com/mozilla/sweet.js/wiki/design
+// This ensure static methods are "inherited"
+// See: https://stackoverflow.com/questions/5441508/how-to-inherit-static-methods-from-base-class-in-javascript
+Object.assign(GPU, GPUCore);
 
-var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
-  this.token = token;
-  this.isExpr = !!isExpr;
-  this.preserveSpace = !!preserveSpace;
-  this.override = override;
-  this.generator = !!generator;
-};
+module.exports = GPU;
+},{"../backend/cpu/runner":55,"../backend/web-gl/runner":65,"../backend/web-gl/validator-kernel":68,"./gpu-core":70,"./utils":75}],72:[function(require,module,exports){
+"use strict";
 
-var types$1 = {
-  b_stat: new TokContext("{", false),
-  b_expr: new TokContext("{", true),
-  b_tmpl: new TokContext("${", false),
-  p_stat: new TokContext("(", false),
-  p_expr: new TokContext("(", true),
-  q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
-  f_stat: new TokContext("function", false),
-  f_expr: new TokContext("function", true),
-  f_expr_gen: new TokContext("function", true, false, null, true),
-  f_gen: new TokContext("function", false, false, null, true)
-};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var pp$7 = Parser.prototype;
+module.exports = function Input(value, size) {
+	_classCallCheck(this, Input);
 
-pp$7.initialContext = function() {
-  return [types$1.b_stat]
+	this.value = value;
+	if (Array.isArray(size)) {
+		this.size = [];
+		for (var i = 0; i < size.length; i++) {
+			this.size[i] = size[i];
+		}
+		while (this.size.length < 3) {
+			this.size.push(1);
+		}
+	} else {
+		if (size.z) {
+			this.size = [size.x, size.y, size.z];
+		} else if (size.y) {
+			this.size = [size.x, size.y, 1];
+		} else {
+			this.size = [size.x, 1, 1];
+		}
+	}
 };
+},{}],73:[function(require,module,exports){
+'use strict';
 
-pp$7.braceIsBlock = function(prevType) {
-  var parent = this.curContext();
-  if (parent === types$1.f_expr || parent === types$1.f_stat)
-    { return true }
-  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
-    { return !parent.isExpr }
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-  // The check for `tt.name && exprAllowed` detects whether we are
-  // after a `yield` or `of` construct. See the `updateContext` for
-  // `tt.name`.
-  if (prevType === types._return || prevType == types.name && this.exprAllowed)
-    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
-  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType == types.arrow)
-    { return true }
-  if (prevType == types.braceL)
-    { return parent === types$1.b_stat }
-  if (prevType == types._var || prevType == types.name)
-    { return false }
-  return !this.exprAllowed
-};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-pp$7.inGeneratorContext = function() {
-  var this$1 = this;
+var gpu = null;
 
-  for (var i = this.context.length - 1; i >= 1; i--) {
-    var context = this$1.context[i];
-    if (context.token === "function")
-      { return context.generator }
-  }
-  return false
-};
+module.exports = function () {
 
-pp$7.updateContext = function(prevType) {
-  var update, type = this.type;
-  if (type.keyword && prevType == types.dot)
-    { this.exprAllowed = false; }
-  else if (update = type.updateContext)
-    { update.call(this, prevType); }
-  else
-    { this.exprAllowed = type.beforeExpr; }
-};
+	/**
+  * @desc WebGl Texture implementation in JS
+  * @constructor Texture
+  * @param {Object} texture 
+  * @param {Array} size 
+  * @param {Array} output
+  * @param {Object} webGl
+  */
+	function Texture(texture, size, output, webGl) {
+		_classCallCheck(this, Texture);
 
-// Token-specific context update code
+		this.texture = texture;
+		this.size = size;
+		this.output = output;
+		this.webGl = webGl;
+		this.kernel = null;
+	}
 
-types.parenR.updateContext = types.braceR.updateContext = function() {
-  if (this.context.length == 1) {
-    this.exprAllowed = true;
-    return
-  }
-  var out = this.context.pop();
-  if (out === types$1.b_stat && this.curContext().token === "function") {
-    out = this.context.pop();
-  }
-  this.exprAllowed = !out.isExpr;
-};
+	/**
+  * @name toArray
+  * @function
+  * @memberOf Texture#
+  *
+  * @desc Converts the Texture into a JavaScript Array.
+  * 
+  * @param {Object} The `gpu` Object
+  *
+  */
 
-types.braceL.updateContext = function(prevType) {
-  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
-  this.exprAllowed = true;
-};
 
-types.dollarBraceL.updateContext = function() {
-  this.context.push(types$1.b_tmpl);
-  this.exprAllowed = true;
-};
+	_createClass(Texture, [{
+		key: 'toArray',
+		value: function toArray(gpu) {
+			if (!gpu) throw new Error('You need to pass the GPU object for toArray to work.');
+			if (this.kernel) return this.kernel(this);
 
-types.parenL.updateContext = function(prevType) {
-  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
-  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
-  this.exprAllowed = true;
-};
+			this.kernel = gpu.createKernel(function (x) {
+				return x[this.thread.z][this.thread.y][this.thread.x];
+			}).setOutput(this.output);
 
-types.incDec.updateContext = function() {
-  // tokExprAllowed stays unchanged
-};
+			return this.kernel(this);
+		}
 
-types._function.updateContext = types._class.updateContext = function(prevType) {
-  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
-      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
-    { this.context.push(types$1.f_expr); }
-  else
-    { this.context.push(types$1.f_stat); }
-  this.exprAllowed = false;
-};
+		/**
+   * @name delete
+   * @desc Deletes the Texture.
+   * @function
+   * @memberOf Texture#
+   *
+   *
+   */
 
-types.backQuote.updateContext = function() {
-  if (this.curContext() === types$1.q_tmpl)
-    { this.context.pop(); }
-  else
-    { this.context.push(types$1.q_tmpl); }
-  this.exprAllowed = false;
-};
+	}, {
+		key: 'delete',
+		value: function _delete() {
+			return this.webGl.deleteTexture(this.texture);
+		}
+	}]);
 
-types.star.updateContext = function(prevType) {
-  if (prevType == types._function) {
-    var index = this.context.length - 1;
-    if (this.context[index] === types$1.f_expr)
-      { this.context[index] = types$1.f_expr_gen; }
-    else
-      { this.context[index] = types$1.f_gen; }
-  }
-  this.exprAllowed = true;
-};
+	return Texture;
+}();
+},{}],74:[function(require,module,exports){
+'use strict';
 
-types.name.updateContext = function(prevType) {
-  var allowed = false;
-  if (this.options.ecmaVersion >= 6) {
-    if (this.value == "of" && !this.exprAllowed ||
-        this.value == "yield" && this.inGeneratorContext())
-      { allowed = true; }
-  }
-  this.exprAllowed = allowed;
-};
+/**
+ *
+ * @desc Reduced subset of Utils, used exclusively in gpu-core.js
+ * Various utility functions / snippets of code that GPU.JS uses internally.\
+ * This covers various snippets of code that is not entirely gpu.js specific (ie. may find uses elsewhere)
+ *
+ * Note that all methods in this class is 'static' by nature `UtilsCore.functionName()`
+ *
+ * @class UtilsCore
+ *
+ */
 
-// Object type used to represent tokens. Note that normally, tokens
-// simply exist as properties on the parser object. This is only
-// used for the onToken callback and the external tokenizer.
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-var Token = function Token(p) {
-  this.type = p.type;
-  this.value = p.value;
-  this.start = p.start;
-  this.end = p.end;
-  if (p.options.locations)
-    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
-  if (p.options.ranges)
-    { this.range = [p.start, p.end]; }
-};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-// ## Tokenizer
+var UtilsCore = function () {
+	function UtilsCore() {
+		_classCallCheck(this, UtilsCore);
+	}
 
-var pp$8 = Parser.prototype;
+	_createClass(UtilsCore, null, [{
+		key: 'isCanvas',
 
-// Are we running under Rhino?
-var isRhino = typeof Packages == "object" && Object.prototype.toString.call(Packages) == "[object JavaPackage]";
 
-// Move to the next token
+		/**
+   * @typedef {Object} webGlContext
+   */
 
-pp$8.next = function() {
-  if (this.options.onToken)
-    { this.options.onToken(new Token(this)); }
+		/**
+   * @typedef {Object} CanvasDOMObject
+   */
 
-  this.lastTokEnd = this.end;
-  this.lastTokStart = this.start;
-  this.lastTokEndLoc = this.endLoc;
-  this.lastTokStartLoc = this.startLoc;
-  this.nextToken();
-};
+		//-----------------------------------------------------------------------------
+		//
+		//  Canvas validation and support
+		//
+		//-----------------------------------------------------------------------------
 
-pp$8.getToken = function() {
-  this.next();
-  return new Token(this)
-};
+		/**
+   * @name isCanvas
+   * @static
+   * @function
+   * @memberOf UtilsCore
+   *
+   *
+   * @desc Return TRUE, on a valid DOM canvas object
+   *
+   * Note: This does just a VERY simply sanity check. And may give false positives.
+   *
+   * @param {CanvasDOMObject} canvasObj - Object to validate
+   *
+   * @returns {Boolean} TRUE if the object is a DOM canvas
+   *
+   */
+		value: function isCanvas(canvasObj) {
+			return canvasObj !== null && canvasObj.nodeName && canvasObj.getContext && canvasObj.nodeName.toUpperCase() === 'CANVAS';
+		}
 
-// If we're in an ES6 environment, make parsers iterable
-if (typeof Symbol !== "undefined")
-  { pp$8[Symbol.iterator] = function() {
-    var this$1 = this;
+		/**
+   * @name isCanvasSupported
+   * @function
+   * @static
+   * @memberOf UtilsCore
+   *
+   * @desc Return TRUE, if browser supports canvas
+   *
+   * @returns {Boolean} TRUE if browser supports canvas
+   *
+   */
 
-    return {
-      next: function () {
-        var token = this$1.getToken();
-        return {
-          done: token.type === types.eof,
-          value: token
-        }
-      }
-    }
-  }; }
+	}, {
+		key: 'isCanvasSupported',
+		value: function isCanvasSupported() {
+			return _isCanvasSupported;
+		}
 
-// Toggle strict mode. Re-reads the next number or string to please
-// pedantic tests (`"use strict"; 010;` should fail).
+		/**
+   * @name initCanvas
+   * @function
+   * @static
+   * @memberOf UtilsCore
+   *
+   * @desc Initiate and returns a canvas, for usage in init_webgl.
+   * Returns only if canvas is supported by browser.
+   *
+   * @returns {CanvasDOMObject} CanvasDOMObject if supported by browser, else null
+   *
+   */
 
-pp$8.curContext = function() {
-  return this.context[this.context.length - 1]
-};
+	}, {
+		key: 'initCanvas',
+		value: function initCanvas() {
+			// Fail fast if browser previously detected no support
+			if (!_isCanvasSupported) {
+				return null;
+			}
 
-// Read a single token, updating the parser object's token-related
-// properties.
+			// Create a new canvas DOM
+			var canvas = document.createElement('canvas');
 
-pp$8.nextToken = function() {
-  var curContext = this.curContext();
-  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+			// Default width and height, to fix webgl issue in safari
+			canvas.width = 2;
+			canvas.height = 2;
 
-  this.start = this.pos;
-  if (this.options.locations) { this.startLoc = this.curPosition(); }
-  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+			// Returns the canvas
+			return canvas;
+		}
 
-  if (curContext.override) { return curContext.override(this) }
-  else { this.readToken(this.fullCharCodeAtPos()); }
-};
+		//-----------------------------------------------------------------------------
+		//
+		//  Webgl validation and support
+		//
+		//-----------------------------------------------------------------------------
 
-pp$8.readToken = function(code) {
-  // Identifier or keyword. '\uXXXX' sequences are allowed in
-  // identifiers, so '\' also dispatches to that.
-  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
-    { return this.readWord() }
 
-  return this.getTokenFromCode(code)
-};
+		/**
+   *
+   * @name isWebGl
+   * @function
+   * @static
+   * @memberOf UtilsCore
+   *
+   * @desc Return TRUE, on a valid webGlContext object
+   *
+   * Note: This does just a VERY simply sanity check. And may give false positives.
+   *
+   * @param {webGlContext} webGlObj - Object to validate
+   *
+   * @returns {Boolean} TRUE if the object is a webGlContext object
+   *
+   */
 
-pp$8.fullCharCodeAtPos = function() {
-  var code = this.input.charCodeAt(this.pos);
-  if (code <= 0xd7ff || code >= 0xe000) { return code }
-  var next = this.input.charCodeAt(this.pos + 1);
-  return (code << 10) + next - 0x35fdc00
-};
+	}, {
+		key: 'isWebGl',
+		value: function isWebGl(webGlObj) {
+			return webGlObj && typeof webGlObj.getExtension === 'function';
+		}
+
+		/**
+   * @name isWebGlSupported
+   * @function
+   * @static
+   * @memberOf UtilsCore
+   *
+   * @desc Return TRUE, if browser supports webgl
+   *
+   * @returns {Boolean} TRUE if browser supports webgl
+   *
+   */
 
-pp$8.skipBlockComment = function() {
-  var this$1 = this;
+	}, {
+		key: 'isWebGlSupported',
+		value: function isWebGlSupported() {
+			return _isWebGlSupported;
+		}
+	}, {
+		key: 'isWebGlDrawBuffersSupported',
+		value: function isWebGlDrawBuffersSupported() {
+			return _isWebGlDrawBuffersSupported;
+		}
 
-  var startLoc = this.options.onComment && this.curPosition();
-  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
-  if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
-  this.pos = end + 2;
-  if (this.options.locations) {
-    lineBreakG.lastIndex = start;
-    var match;
-    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
-      ++this$1.curLine;
-      this$1.lineStart = match.index + match[0].length;
-    }
-  }
-  if (this.options.onComment)
-    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
-                           startLoc, this.curPosition()); }
-};
+		// Default webgl options to use
 
-pp$8.skipLineComment = function(startSkip) {
-  var this$1 = this;
+	}, {
+		key: 'initWebGlDefaultOptions',
+		value: function initWebGlDefaultOptions() {
+			return {
+				alpha: false,
+				depth: false,
+				antialias: false
+			};
+		}
 
-  var start = this.pos;
-  var startLoc = this.options.onComment && this.curPosition();
-  var ch = this.input.charCodeAt(this.pos += startSkip);
-  while (this.pos < this.input.length && !isNewLine(ch)) {
-    ch = this$1.input.charCodeAt(++this$1.pos);
-  }
-  if (this.options.onComment)
-    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
-                           startLoc, this.curPosition()); }
-};
+		/**
+   * @name initWebGl
+   * @function
+   * @static
+   * @memberOf UtilsCore
+   *
+   * @desc Initiate and returns a webGl, from a canvas object
+   * Returns only if webGl is supported by browser.
+   *
+   * @param {CanvasDOMObject} canvasObj - Object to validate
+   *
+   * @returns {CanvasDOMObject} CanvasDOMObject if supported by browser, else null
+   *
+   */
 
-// Called at the start of the parse and after every token. Skips
-// whitespace and comments, and.
+	}, {
+		key: 'initWebGl',
+		value: function initWebGl(canvasObj) {
 
-pp$8.skipSpace = function() {
-  var this$1 = this;
+			// First time setup, does the browser support check memorizer
+			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
+				if (!_isCanvasSupported) {
+					return null;
+				}
+			}
 
-  loop: while (this.pos < this.input.length) {
-    var ch = this$1.input.charCodeAt(this$1.pos);
-    switch (ch) {
-    case 32: case 160: // ' '
-      ++this$1.pos;
-      break
-    case 13:
-      if (this$1.input.charCodeAt(this$1.pos + 1) === 10) {
-        ++this$1.pos;
-      }
-    case 10: case 8232: case 8233:
-      ++this$1.pos;
-      if (this$1.options.locations) {
-        ++this$1.curLine;
-        this$1.lineStart = this$1.pos;
-      }
-      break
-    case 47: // '/'
-      switch (this$1.input.charCodeAt(this$1.pos + 1)) {
-      case 42: // '*'
-        this$1.skipBlockComment();
-        break
-      case 47:
-        this$1.skipLineComment(2);
-        break
-      default:
-        break loop
-      }
-      break
-    default:
-      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-        ++this$1.pos;
-      } else {
-        break loop
-      }
-    }
-  }
-};
+			// Fail fast for invalid canvas object
+			if (!UtilsCore.isCanvas(canvasObj)) {
+				throw new Error('Invalid canvas object - ' + canvasObj);
+			}
 
-// Called at the end of every token. Sets `end`, `val`, and
-// maintains `context` and `exprAllowed`, and skips the space after
-// the token, so that the next one's `start` will point at the
-// right position.
+			// Create a new canvas DOM
+			var webGl = canvasObj.getContext('experimental-webgl', UtilsCore.initWebGlDefaultOptions()) || canvasObj.getContext('webgl', UtilsCore.initWebGlDefaultOptions());
 
-pp$8.finishToken = function(type, val) {
-  this.end = this.pos;
-  if (this.options.locations) { this.endLoc = this.curPosition(); }
-  var prevType = this.type;
-  this.type = type;
-  this.value = val;
+			if (webGl) {
+				// Get the extension that is needed
+				webGl.OES_texture_float = webGl.getExtension('OES_texture_float');
+				webGl.OES_texture_float_linear = webGl.getExtension('OES_texture_float_linear');
+				webGl.OES_element_index_uint = webGl.getExtension('OES_element_index_uint');
+			}
 
-  this.updateContext(prevType);
-};
+			// Returns the canvas
+			return webGl;
+		}
+	}]);
 
-// ### Token reading
+	return UtilsCore;
+}();
 
-// This is the function that is called to fetch the next token. It
-// is somewhat obscure, because it works in character codes rather
-// than characters, and because operator parsing has been inlined
-// into it.
+//-----------------------------------------------------------------------------
 //
-// All in the name of speed.
+//  Canvas & Webgl validation and support constants
 //
-pp$8.readToken_dot = function() {
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next >= 48 && next <= 57) { return this.readNumber(true) }
-  var next2 = this.input.charCodeAt(this.pos + 2);
-  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-    this.pos += 3;
-    return this.finishToken(types.ellipsis)
-  } else {
-    ++this.pos;
-    return this.finishToken(types.dot)
-  }
-};
+//-----------------------------------------------------------------------------
 
-pp$8.readToken_slash = function() { // '/'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.slash, 1)
-};
+var _isCanvasSupported = typeof document !== 'undefined' ? UtilsCore.isCanvas(document.createElement('canvas')) : false;
+var _testingWebGl = UtilsCore.initWebGl(UtilsCore.initCanvas());
+var _isWebGlSupported = UtilsCore.isWebGl(_testingWebGl);
+var _isWebGlDrawBuffersSupported = _isWebGlSupported && Boolean(_testingWebGl.getExtension('WEBGL_draw_buffers'));
 
-pp$8.readToken_mult_modulo_exp = function(code) { // '%*'
-  var next = this.input.charCodeAt(this.pos + 1);
-  var size = 1;
-  var tokentype = code === 42 ? types.star : types.modulo;
+if (_isWebGlSupported) {
+	UtilsCore.OES_texture_float = _testingWebGl.OES_texture_float;
+	UtilsCore.OES_texture_float_linear = _testingWebGl.OES_texture_float_linear;
+	UtilsCore.OES_element_index_uint = _testingWebGl.OES_element_index_uint;
+} else {
+	UtilsCore.OES_texture_float = false;
+	UtilsCore.OES_texture_float_linear = false;
+	UtilsCore.OES_element_index_uint = false;
+}
 
-  // exponentiation operator ** and **=
-  if (this.options.ecmaVersion >= 7 && code == 42 && next === 42) {
-    ++size;
-    tokentype = types.starstar;
-    next = this.input.charCodeAt(this.pos + 2);
-  }
+module.exports = UtilsCore;
+},{}],75:[function(require,module,exports){
+'use strict';
 
-  if (next === 61) { return this.finishOp(types.assign, size + 1) }
-  return this.finishOp(tokentype, size)
-};
+/**
+ * 
+ * @classdesc Various utility functions / snippets of code that GPU.JS uses internally.\
+ * This covers various snippets of code that is not entirely gpu.js specific (ie. may find uses elsewhere)
+ *
+ * Note that all methods in this class are *static* by nature `Utils.functionName()`
+ * 
+ * @class Utils
+ * @extends UtilsCore
+ *
+ */
 
-pp$8.readToken_pipe_amp = function(code) { // '|&'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
-};
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
-pp$8.readToken_caret = function() { // '^'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.bitwiseXOR, 1)
-};
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-pp$8.readToken_plus_min = function(code) { // '+-'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === code) {
-    if (next == 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 62 &&
-        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
-      // A `-->` line comment
-      this.skipLineComment(3);
-      this.skipSpace();
-      return this.nextToken()
-    }
-    return this.finishOp(types.incDec, 2)
-  }
-  if (next === 61) { return this.finishOp(types.assign, 2) }
-  return this.finishOp(types.plusMin, 1)
-};
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var UtilsCore = require("./utils-core");
+var Input = require('./input');
+var Texture = require('./texture');
+// FUNCTION_NAME regex
+var FUNCTION_NAME = /function ([^(]*)/;
 
-pp$8.readToken_lt_gt = function(code) { // '<>'
-  var next = this.input.charCodeAt(this.pos + 1);
-  var size = 1;
-  if (next === code) {
-    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
-    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
-    return this.finishOp(types.bitShift, size)
-  }
-  if (next == 33 && code == 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) == 45 &&
-      this.input.charCodeAt(this.pos + 3) == 45) {
-    // `<!--`, an XML-style comment that should be interpreted as a line comment
-    this.skipLineComment(4);
-    this.skipSpace();
-    return this.nextToken()
-  }
-  if (next === 61) { size = 2; }
-  return this.finishOp(types.relational, size)
-};
+// STRIP COMMENTS regex
+var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
 
-pp$8.readToken_eq_excl = function(code) { // '=!'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
-  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
-    this.pos += 2;
-    return this.finishToken(types.arrow)
-  }
-  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
-};
+// ARGUMENT NAMES regex
+var ARGUMENT_NAMES = /([^\s,]+)/g;
 
-pp$8.getTokenFromCode = function(code) {
-  switch (code) {
-  // The interpretation of a dot depends on whether it is followed
-  // by a digit or another two dots.
-  case 46: // '.'
-    return this.readToken_dot()
+var _systemEndianness = function () {
+	var b = new ArrayBuffer(4);
+	var a = new Uint32Array(b);
+	var c = new Uint8Array(b);
+	a[0] = 0xdeadbeef;
+	if (c[0] === 0xef) return 'LE';
+	if (c[0] === 0xde) return 'BE';
+	throw new Error('unknown endianness');
+}();
 
-  // Punctuation tokens.
-  case 40: ++this.pos; return this.finishToken(types.parenL)
-  case 41: ++this.pos; return this.finishToken(types.parenR)
-  case 59: ++this.pos; return this.finishToken(types.semi)
-  case 44: ++this.pos; return this.finishToken(types.comma)
-  case 91: ++this.pos; return this.finishToken(types.bracketL)
-  case 93: ++this.pos; return this.finishToken(types.bracketR)
-  case 123: ++this.pos; return this.finishToken(types.braceL)
-  case 125: ++this.pos; return this.finishToken(types.braceR)
-  case 58: ++this.pos; return this.finishToken(types.colon)
-  case 63: ++this.pos; return this.finishToken(types.question)
+var _isFloatReadPixelsSupported = null;
 
-  case 96: // '`'
-    if (this.options.ecmaVersion < 6) { break }
-    ++this.pos;
-    return this.finishToken(types.backQuote)
+var _isMixedIdentifiersSupported = function () {
+	try {
+		new Function('let i = 1; const j = 1;')();
+		return true;
+	} catch (e) {
+		return false;
+	}
+}();
 
-  case 48: // '0'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number
-    if (this.options.ecmaVersion >= 6) {
-      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number
-      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number
-    }
+var Utils = function (_UtilsCore) {
+	_inherits(Utils, _UtilsCore);
 
-  // Anything else beginning with a digit is an integer, octal
-  // number, or float.
-  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
-    return this.readNumber(false)
+	function Utils() {
+		_classCallCheck(this, Utils);
 
-  // Quotes produce strings.
-  case 34: case 39: // '"', "'"
-    return this.readString(code)
+		return _possibleConstructorReturn(this, (Utils.__proto__ || Object.getPrototypeOf(Utils)).apply(this, arguments));
+	}
 
-  // Operators are parsed inline in tiny state machines. '=' (61) is
-  // often referred to. `finishOp` simply skips the amount of
-  // characters it is given as second argument, and returns a token
-  // of the type given by its first argument.
+	_createClass(Utils, null, [{
+		key: 'systemEndianness',
 
-  case 47: // '/'
-    return this.readToken_slash()
 
-  case 37: case 42: // '%*'
-    return this.readToken_mult_modulo_exp(code)
+		//-----------------------------------------------------------------------------
+		//
+		//  System values support (currently only endianness)
+		//
+		//-----------------------------------------------------------------------------
 
-  case 124: case 38: // '|&'
-    return this.readToken_pipe_amp(code)
+		/**
+   * @memberOf Utils
+   * @name systemEndianness
+   * @function
+   * @static
+   *
+   * Gets the system endianness, and cache it
+   *
+   * @returns {String} 'LE' or 'BE' depending on system architecture
+   *
+   * Credit: https://gist.github.com/TooTallNate/4750953
+   */
+		value: function systemEndianness() {
+			return _systemEndianness;
+		}
 
-  case 94: // '^'
-    return this.readToken_caret()
+		//-----------------------------------------------------------------------------
+		//
+		//  Function and function string validations
+		//
+		//-----------------------------------------------------------------------------
 
-  case 43: case 45: // '+-'
-    return this.readToken_plus_min(code)
+		/**
+   * @memberOf Utils
+   * @name isFunction
+   * @function
+   * @static
+   *
+   * Return TRUE, on a JS function
+   *
+   * @param {Function} funcObj - Object to validate if its a function
+   *
+   * @returns	{Boolean} TRUE if the object is a JS function
+   *
+   */
 
-  case 60: case 62: // '<>'
-    return this.readToken_lt_gt(code)
+	}, {
+		key: 'isFunction',
+		value: function isFunction(funcObj) {
+			return typeof funcObj === 'function';
+		}
 
-  case 61: case 33: // '=!'
-    return this.readToken_eq_excl(code)
+		/**
+   * @memberOf Utils
+   * @name isFunctionString
+   * @function
+   * @static
+   *
+   * Return TRUE, on a valid JS function string
+   *
+   * Note: This does just a VERY simply sanity check. And may give false positives.
+   *
+   * @param {String} funcStr - String of JS function to validate
+   *
+   * @returns {Boolean} TRUE if the string passes basic validation
+   *
+   */
 
-  case 126: // '~'
-    return this.finishOp(types.prefix, 1)
-  }
+	}, {
+		key: 'isFunctionString',
+		value: function isFunctionString(funcStr) {
+			if (funcStr !== null) {
+				return funcStr.toString().slice(0, 'function'.length).toLowerCase() === 'function';
+			}
+			return false;
+		}
 
-  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
-};
+		/**
+   * @memberOf Utils
+   * @name getFunctionName_fromString
+   * @function
+   * @static
+   *
+   * Return the function name from a JS function string
+   *
+   * @param {String} funcStr - String of JS function to validate
+   *
+   * @returns {String} Function name string (if found)
+   *
+   */
 
-pp$8.finishOp = function(type, size) {
-  var str = this.input.slice(this.pos, this.pos + size);
-  this.pos += size;
-  return this.finishToken(type, str)
-};
+	}, {
+		key: 'getFunctionNameFromString',
+		value: function getFunctionNameFromString(funcStr) {
+			return FUNCTION_NAME.exec(funcStr)[1];
+		}
+	}, {
+		key: 'getFunctionBodyFromString',
+		value: function getFunctionBodyFromString(funcStr) {
+			return funcStr.substring(funcStr.indexOf('{') + 1, funcStr.lastIndexOf('}'));
+		}
 
-// Parse a regular expression. Some context-awareness is necessary,
-// since a '/' inside a '[]' set does not end the expression.
+		/**
+   * @memberOf Utils
+   * @name getParamNames_fromString
+   * @function
+   * @static
+   *
+   * Return list of parameter names extracted from the JS function string
+   *
+   * @param {String} funcStr - String of JS function to validate
+   *
+   * @returns {String[]}  Array representing all the parameter names
+   *
+   */
 
-function tryCreateRegexp(src, flags, throwErrorAt, parser) {
-  try {
-    return new RegExp(src, flags)
-  } catch (e) {
-    if (throwErrorAt !== undefined) {
-      if (e instanceof SyntaxError) { parser.raise(throwErrorAt, "Error parsing regular expression: " + e.message); }
-      throw e
-    }
-  }
-}
+	}, {
+		key: 'getParamNamesFromString',
+		value: function getParamNamesFromString(func) {
+			var fnStr = func.toString().replace(STRIP_COMMENTS, '');
+			var result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
+			if (result === null) result = [];
+			return result;
+		}
+
+		//-----------------------------------------------------------------------------
+		//
+		//  Object / function cloning and manipulation
+		//
+		//-----------------------------------------------------------------------------
+
+		/**
+   * @memberOf Utils
+   * @name clone
+   * @function
+   * @static
+   *
+   * Returns a clone
+   *
+   * @param {Object} obj - Object to clone
+   *
+   * @returns {Object}  Cloned object
+   *
+   */
 
-var regexpUnicodeSupport = !!tryCreateRegexp("\uffff", "u");
+	}, {
+		key: 'clone',
+		value: function clone(obj) {
+			if (obj === null || (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj.hasOwnProperty('isActiveClone')) return obj;
 
-pp$8.readRegexp = function() {
-  var this$1 = this;
+			var temp = obj.constructor(); // changed
 
-  var escaped, inClass, start = this.pos;
-  for (;;) {
-    if (this$1.pos >= this$1.input.length) { this$1.raise(start, "Unterminated regular expression"); }
-    var ch = this$1.input.charAt(this$1.pos);
-    if (lineBreak.test(ch)) { this$1.raise(start, "Unterminated regular expression"); }
-    if (!escaped) {
-      if (ch === "[") { inClass = true; }
-      else if (ch === "]" && inClass) { inClass = false; }
-      else if (ch === "/" && !inClass) { break }
-      escaped = ch === "\\";
-    } else { escaped = false; }
-    ++this$1.pos;
-  }
-  var content = this.input.slice(start, this.pos);
-  ++this.pos;
-  // Need to use `readWord1` because '\uXXXX' sequences are allowed
-  // here (don't ask).
-  var mods = this.readWord1();
-  var tmp = content, tmpFlags = "";
-  if (mods) {
-    var validFlags = /^[gim]*$/;
-    if (this.options.ecmaVersion >= 6) { validFlags = /^[gimuy]*$/; }
-    if (this.options.ecmaVersion >= 9) { validFlags = /^[gimsuy]*$/; }
-    if (!validFlags.test(mods)) { this.raise(start, "Invalid regular expression flag"); }
-    if (mods.indexOf("u") >= 0) {
-      if (regexpUnicodeSupport) {
-        tmpFlags = "u";
-      } else {
-        // Replace each astral symbol and every Unicode escape sequence that
-        // possibly represents an astral symbol or a paired surrogate with a
-        // single ASCII symbol to avoid throwing on regular expressions that
-        // are only valid in combination with the `/u` flag.
-        // Note: replacing with the ASCII symbol `x` might cause false
-        // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
-        // perfectly valid pattern that is equivalent to `[a-b]`, but it would
-        // be replaced by `[x-b]` which throws an error.
-        tmp = tmp.replace(/\\u\{([0-9a-fA-F]+)\}/g, function (_match, code, offset) {
-          code = Number("0x" + code);
-          if (code > 0x10FFFF) { this$1.raise(start + offset + 3, "Code point out of bounds"); }
-          return "x"
-        });
-        tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
-        tmpFlags = tmpFlags.replace("u", "");
-      }
-    }
-  }
-  // Detect invalid regular expressions.
-  var value = null;
-  // Rhino's regular expression parser is flaky and throws uncatchable exceptions,
-  // so don't do detection if we are running under Rhino
-  if (!isRhino) {
-    tryCreateRegexp(tmp, tmpFlags, start, this);
-    // Get a regular expression object for this pattern-flag pair, or `null` in
-    // case the current environment doesn't support the flags it uses.
-    value = tryCreateRegexp(content, mods);
-  }
-  return this.finishToken(types.regexp, {pattern: content, flags: mods, value: value})
-};
+			for (var key in obj) {
+				if (Object.prototype.hasOwnProperty.call(obj, key)) {
+					obj.isActiveClone = null;
+					temp[key] = Utils.clone(obj[key]);
+					delete obj.isActiveClone;
+				}
+			}
 
-// Read an integer in the given radix. Return null if zero digits
-// were read, the integer value otherwise. When `len` is given, this
-// will return `null` unless the integer has exactly `len` digits.
+			return temp;
+		}
 
-pp$8.readInt = function(radix, len) {
-  var this$1 = this;
+		/**
+   * @memberOf Utils
+   * @name newPromise
+   * @function
+   * @static
+   *
+   * Returns a `new Promise` object based on the underlying implmentation
+   *
+   * @param {Function} executor - Promise builder function
+   *
+   * @returns {Promise}  Promise object
+   *
+   */
 
-  var start = this.pos, total = 0;
-  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    var code = this$1.input.charCodeAt(this$1.pos), val = (void 0);
-    if (code >= 97) { val = code - 97 + 10; } // a
-    else if (code >= 65) { val = code - 65 + 10; } // A
-    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
-    else { val = Infinity; }
-    if (val >= radix) { break }
-    ++this$1.pos;
-    total = total * radix + val;
-  }
-  if (this.pos === start || len != null && this.pos - start !== len) { return null }
+	}, {
+		key: 'newPromise',
+		value: function newPromise(executor) {
+			var simple = Promise || small_promise;
+			if (simple === null) {
+				throw TypeError('Browser is missing Promise implementation. Consider adding small_promise.js polyfill');
+			}
+			return new simple(executor);
+		}
 
-  return total
-};
+		/**
+   * @memberOf Utils
+   * @name functionBinder
+   * @function
+   * @static
+   *
+   * Limited implementation of Function.bind, with fallback
+   *
+   * @param {Function} inFunc - to setup bind on
+   * @param {Object} thisObj - The this parameter to assume inside the binded function
+   *
+   * @returns {Function}  The binded function
+   *
+   */
 
-pp$8.readRadixNumber = function(radix) {
-  this.pos += 2; // 0x
-  var val = this.readInt(radix);
-  if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
-  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
-  return this.finishToken(types.num, val)
-};
+	}, {
+		key: 'functionBinder',
+		value: function functionBinder(inFunc, thisObj) {
+			if (inFunc.bind) {
+				return inFunc.bind(thisObj);
+			}
 
-// Read an integer, octal integer, or floating-point number.
+			return function () {
+				var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+				return inFunc.apply(thisObj, args);
+			};
+		}
 
-pp$8.readNumber = function(startsWithDot) {
-  var start = this.pos;
-  if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
-  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
-  if (octal && this.strict) { this.raise(start, "Invalid number"); }
-  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
-  var next = this.input.charCodeAt(this.pos);
-  if (next === 46 && !octal) { // '.'
-    ++this.pos;
-    this.readInt(10);
-    next = this.input.charCodeAt(this.pos);
-  }
-  if ((next === 69 || next === 101) && !octal) { // 'eE'
-    next = this.input.charCodeAt(++this.pos);
-    if (next === 43 || next === 45) { ++this.pos; } // '+-'
-    if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
-  }
-  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+		/**
+   * @memberOf Utils
+   * @name isArray
+   * @function
+   * @static
+   *
+   * * Checks if is an array or Array-like object
+   *
+   * @param {Object} arg - The argument object to check if is array
+   *
+   * @returns {Boolean}  true if is array or Array-like object
+   *
+   */
 
-  var str = this.input.slice(start, this.pos);
-  var val = octal ? parseInt(str, 8) : parseFloat(str);
-  return this.finishToken(types.num, val)
-};
+	}, {
+		key: 'isArray',
+		value: function isArray(array) {
+			if (isNaN(array.length)) {
+				return false;
+			}
 
-// Read a string value, interpreting backslash-escapes.
+			return true;
+		}
 
-pp$8.readCodePoint = function() {
-  var ch = this.input.charCodeAt(this.pos), code;
+		/**
+   * @memberOf Utils
+   * @name getArgumentType
+   * @function
+   * @static
+   *
+   * Evaluate the argument type, to apply respective logic for it
+   *
+   * @param {Object} arg - The argument object to evaluate type
+   *
+   * @returns {String}  Argument type Array/Number/Texture/Unknown
+   *
+   */
 
-  if (ch === 123) { // '{'
-    if (this.options.ecmaVersion < 6) { this.unexpected(); }
-    var codePos = ++this.pos;
-    code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
-    ++this.pos;
-    if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
-  } else {
-    code = this.readHexChar(4);
-  }
-  return code
-};
+	}, {
+		key: 'getArgumentType',
+		value: function getArgumentType(arg) {
+			if (Utils.isArray(arg)) {
+				return 'Array';
+			} else if (typeof arg === 'number') {
+				return 'Number';
+			} else if (arg instanceof Texture) {
+				return 'Texture';
+			} else if (arg instanceof Input) {
+				return 'Input';
+			} else {
+				return 'Unknown';
+			}
+		}
+		/**
+   * @typedef {Object} gpuJSObject
+   */
 
-function codePointToString(code) {
-  // UTF-16 Decoding
-  if (code <= 0xFFFF) { return String.fromCharCode(code) }
-  code -= 0x10000;
-  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
-}
+		/**
+   * @memberOf Utils
+   * @name isFloatReadPixelsSupported
+   * @function
+   * @static
+   *
+   * Checks if the browser supports readPixels with float type
+   *
+   * @param {gpuJSObject} gpu - the gpu object
+   *
+   * @returns {Boolean} true if browser supports
+   *
+   */
 
-pp$8.readString = function(quote) {
-  var this$1 = this;
+	}, {
+		key: 'isFloatReadPixelsSupported',
+		value: function isFloatReadPixelsSupported() {
+			if (_isFloatReadPixelsSupported !== null) {
+				return _isFloatReadPixelsSupported;
+			}
 
-  var out = "", chunkStart = ++this.pos;
-  for (;;) {
-    if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated string constant"); }
-    var ch = this$1.input.charCodeAt(this$1.pos);
-    if (ch === quote) { break }
-    if (ch === 92) { // '\'
-      out += this$1.input.slice(chunkStart, this$1.pos);
-      out += this$1.readEscapedChar(false);
-      chunkStart = this$1.pos;
-    } else {
-      if (isNewLine(ch)) { this$1.raise(this$1.start, "Unterminated string constant"); }
-      ++this$1.pos;
-    }
-  }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(types.string, out)
-};
+			var GPU = require('../index');
+			var x = new GPU({
+				mode: 'webgl-validator'
+			}).createKernel(function () {
+				return 1;
+			}, {
+				output: [2],
+				floatTextures: true,
+				floatOutput: true,
+				floatOutputForce: true
+			})();
 
-// Reads template string tokens.
+			_isFloatReadPixelsSupported = x[0] === 1;
 
-var INVALID_TEMPLATE_ESCAPE_ERROR = {};
+			return _isFloatReadPixelsSupported;
+		}
+	}, {
+		key: 'isMixedIdentifiersSupported',
+		value: function isMixedIdentifiersSupported() {
+			return _isMixedIdentifiersSupported;
+		}
+	}, {
+		key: 'dimToTexSize',
+		value: function dimToTexSize(opt, dimensions, output) {
+			var numTexels = dimensions[0];
+			for (var i = 1; i < dimensions.length; i++) {
+				numTexels *= dimensions[i];
+			}
 
-pp$8.tryReadTemplateToken = function() {
-  this.inTemplateElement = true;
-  try {
-    this.readTmplToken();
-  } catch (err) {
-    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
-      this.readInvalidTemplateToken();
-    } else {
-      throw err
-    }
-  }
+			if (opt.floatTextures && (!output || opt.floatOutput)) {
+				numTexels = Math.ceil(numTexels / 4);
+			}
 
-  this.inTemplateElement = false;
-};
+			var w = Math.ceil(Math.sqrt(numTexels));
+			return [w, w];
+		}
 
-pp$8.invalidStringToken = function(position, message) {
-  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
-    throw INVALID_TEMPLATE_ESCAPE_ERROR
-  } else {
-    this.raise(position, message);
-  }
-};
+		/**
+   * @memberOf Utils
+   * @name getDimensions
+   * @function
+   * @static
+   *
+   * Return the dimension of an array.
+   * 
+   * @param {Array|String} x - The array
+   * @param {number} [pad] - To include padding in the dimension calculation [Optional]
+   *
+   *
+   *
+   */
 
-pp$8.readTmplToken = function() {
-  var this$1 = this;
+	}, {
+		key: 'getDimensions',
+		value: function getDimensions(x, pad) {
+			var ret = void 0;
+			if (Utils.isArray(x)) {
+				var dim = [];
+				var temp = x;
+				while (Utils.isArray(temp)) {
+					dim.push(temp.length);
+					temp = temp[0];
+				}
+				ret = dim.reverse();
+			} else if (x instanceof Texture) {
+				ret = x.output;
+			} else if (x instanceof Input) {
+				ret = x.size;
+			} else {
+				throw 'Unknown dimensions of ' + x;
+			}
 
-  var out = "", chunkStart = this.pos;
-  for (;;) {
-    if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated template"); }
-    var ch = this$1.input.charCodeAt(this$1.pos);
-    if (ch === 96 || ch === 36 && this$1.input.charCodeAt(this$1.pos + 1) === 123) { // '`', '${'
-      if (this$1.pos === this$1.start && (this$1.type === types.template || this$1.type === types.invalidTemplate)) {
-        if (ch === 36) {
-          this$1.pos += 2;
-          return this$1.finishToken(types.dollarBraceL)
-        } else {
-          ++this$1.pos;
-          return this$1.finishToken(types.backQuote)
-        }
-      }
-      out += this$1.input.slice(chunkStart, this$1.pos);
-      return this$1.finishToken(types.template, out)
-    }
-    if (ch === 92) { // '\'
-      out += this$1.input.slice(chunkStart, this$1.pos);
-      out += this$1.readEscapedChar(true);
-      chunkStart = this$1.pos;
-    } else if (isNewLine(ch)) {
-      out += this$1.input.slice(chunkStart, this$1.pos);
-      ++this$1.pos;
-      switch (ch) {
-      case 13:
-        if (this$1.input.charCodeAt(this$1.pos) === 10) { ++this$1.pos; }
-      case 10:
-        out += "\n";
-        break
-      default:
-        out += String.fromCharCode(ch);
-        break
-      }
-      if (this$1.options.locations) {
-        ++this$1.curLine;
-        this$1.lineStart = this$1.pos;
-      }
-      chunkStart = this$1.pos;
-    } else {
-      ++this$1.pos;
-    }
-  }
-};
+			if (pad) {
+				ret = Utils.clone(ret);
+				while (ret.length < 3) {
+					ret.push(1);
+				}
+			}
 
-// Reads a template token to search for the end, without validating any escape sequences
-pp$8.readInvalidTemplateToken = function() {
-  var this$1 = this;
+			return ret;
+		}
 
-  for (; this.pos < this.input.length; this.pos++) {
-    switch (this$1.input[this$1.pos]) {
-    case "\\":
-      ++this$1.pos;
-      break
+		/**
+   * @memberOf Utils
+   * @name pad
+   * @function
+   * @static
+   *
+   * Pad an array AND its elements with leading and ending zeros
+   *
+   * @param {Array} arr - the array to pad zeros to
+   * @param {number} padding - amount of padding
+   *
+   * @returns {Array} Array with leading and ending zeros, and all the elements padded by zeros.
+   *
+   */
 
-    case "$":
-      if (this$1.input[this$1.pos + 1] !== "{") {
-        break
-      }
-    // falls through
+	}, {
+		key: 'pad',
+		value: function pad(arr, padding) {
+			function zeros(n) {
+				return Array.apply(null, new Array(n)).map(Number.prototype.valueOf, 0);
+			}
 
-    case "`":
-      return this$1.finishToken(types.invalidTemplate, this$1.input.slice(this$1.start, this$1.pos))
+			var len = arr.length + padding * 2;
 
-    // no default
-    }
-  }
-  this.raise(this.start, "Unterminated template");
-};
+			var ret = arr.map(function (x) {
+				return [].concat(zeros(padding), x, zeros(padding));
+			});
 
-// Used to read escaped characters
+			for (var i = 0; i < padding; i++) {
+				ret = [].concat([zeros(len)], ret, [zeros(len)]);
+			}
 
-pp$8.readEscapedChar = function(inTemplate) {
-  var ch = this.input.charCodeAt(++this.pos);
-  ++this.pos;
-  switch (ch) {
-  case 110: return "\n" // 'n' -> '\n'
-  case 114: return "\r" // 'r' -> '\r'
-  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
-  case 117: return codePointToString(this.readCodePoint()) // 'u'
-  case 116: return "\t" // 't' -> '\t'
-  case 98: return "\b" // 'b' -> '\b'
-  case 118: return "\u000b" // 'v' -> '\u000b'
-  case 102: return "\f" // 'f' -> '\f'
-  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\r\n'
-  case 10: // ' \n'
-    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
-    return ""
-  default:
-    if (ch >= 48 && ch <= 55) {
-      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
-      var octal = parseInt(octalStr, 8);
-      if (octal > 255) {
-        octalStr = octalStr.slice(0, -1);
-        octal = parseInt(octalStr, 8);
-      }
-      if (octalStr !== "0" && (this.strict || inTemplate)) {
-        this.invalidStringToken(this.pos - 2, "Octal literal in strict mode");
-      }
-      this.pos += octalStr.length - 1;
-      return String.fromCharCode(octal)
-    }
-    return String.fromCharCode(ch)
-  }
-};
+			return ret;
+		}
 
-// Used to read character escape sequences ('\x', '\u', '\U').
+		/**
+   * @memberOf Utils
+   * @name flatten2dArrayTo
+   * @function
+   * @static
+   *
+   * Puts a nested 2d array into a one-dimensional target array
+   * @param {Array|*} array
+   * @param {Float32Array|Float64Array} target
+   */
 
-pp$8.readHexChar = function(len) {
-  var codePos = this.pos;
-  var n = this.readInt(16, len);
-  if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
-  return n
-};
+	}, {
+		key: 'flatten2dArrayTo',
+		value: function flatten2dArrayTo(array, target) {
+			var offset = 0;
+			for (var y = 0; y < array.length; y++) {
+				target.set(array[y], offset);
+				offset += array[y].length;
+			}
+		}
 
-// Read an identifier, and return it as a string. Sets `this.containsEsc`
-// to whether the word contained a '\u' escape.
-//
-// Incrementally adds only escaped chars, adding other chunks as-is
-// as a micro-optimization.
+		/**
+   * @memberOf Utils
+   * @name flatten3dArrayTo
+   * @function
+   * @static
+   *
+   * Puts a nested 3d array into a one-dimensional target array
+   * @param {Array|*} array
+   * @param {Float32Array|Float64Array} target
+   */
 
-pp$8.readWord1 = function() {
-  var this$1 = this;
+	}, {
+		key: 'flatten3dArrayTo',
+		value: function flatten3dArrayTo(array, target) {
+			var offset = 0;
+			for (var z = 0; z < array.length; z++) {
+				for (var y = 0; y < array[z].length; y++) {
+					target.set(array[z][y], offset);
+					offset += array[z][y].length;
+				}
+			}
+		}
 
-  this.containsEsc = false;
-  var word = "", first = true, chunkStart = this.pos;
-  var astral = this.options.ecmaVersion >= 6;
-  while (this.pos < this.input.length) {
-    var ch = this$1.fullCharCodeAtPos();
-    if (isIdentifierChar(ch, astral)) {
-      this$1.pos += ch <= 0xffff ? 1 : 2;
-    } else if (ch === 92) { // "\"
-      this$1.containsEsc = true;
-      word += this$1.input.slice(chunkStart, this$1.pos);
-      var escStart = this$1.pos;
-      if (this$1.input.charCodeAt(++this$1.pos) != 117) // "u"
-        { this$1.invalidStringToken(this$1.pos, "Expecting Unicode escape sequence \\uXXXX"); }
-      ++this$1.pos;
-      var esc = this$1.readCodePoint();
-      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
-        { this$1.invalidStringToken(escStart, "Invalid Unicode escape"); }
-      word += codePointToString(esc);
-      chunkStart = this$1.pos;
-    } else {
-      break
-    }
-    first = false;
-  }
-  return word + this.input.slice(chunkStart, this.pos)
-};
+		/**
+   * @memberOf Utils
+   * @name flatten3dArrayTo
+   * @function
+   * @static
+   *
+   * Puts a nested 1d, 2d, or 3d array into a one-dimensional target array
+   * @param {Array|*} array
+   * @param {Float32Array|Float64Array} target
+   */
 
-// Read an identifier or keyword token. Will check for reserved
-// words when necessary.
+	}, {
+		key: 'flattenTo',
+		value: function flattenTo(array, target) {
+			if (Utils.isArray(array[0])) {
+				if (Utils.isArray(array[0][0])) {
+					Utils.flatten3dArrayTo(array, target);
+				} else {
+					Utils.flatten2dArrayTo(array, target);
+				}
+			} else {
+				target.set(array);
+			}
+		}
 
-pp$8.readWord = function() {
-  var word = this.readWord1();
-  var type = types.name;
-  if (this.keywords.test(word)) {
-    if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword " + word); }
-    type = keywords$1[word];
-  }
-  return this.finishToken(type, word)
-};
+		/**
+   * @memberOf Utils
+   * @name splitArray
+   * @function
+   * @static
+   *
+   * Splits an array into smaller arrays.
+   * Number of elements in one small chunk is given by `part`
+   *
+   * @param {Array} array - The array to split into chunks
+   * @param {Array} part - elements in one chunk
+   *
+  	 * @returns {Array} An array of smaller chunks
+   *
+   */
 
-// Acorn is a tiny, fast JavaScript parser written in JavaScript.
-//
-// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
-// various contributors and released under an MIT license.
-//
-// Git repositories for Acorn are available at
-//
-//     http://marijnhaverbeke.nl/git/acorn
-//     https://github.com/acornjs/acorn.git
-//
-// Please use the [github bug tracker][ghbt] to report issues.
-//
-// [ghbt]: https://github.com/acornjs/acorn/issues
-//
-// This file defines the main parser interface. The library also comes
-// with a [error-tolerant parser][dammit] and an
-// [abstract syntax tree walker][walk], defined in other files.
-//
-// [dammit]: acorn_loose.js
-// [walk]: util/walk.js
+	}, {
+		key: 'splitArray',
+		value: function splitArray(array, part) {
+			var result = [];
+			for (var i = 0; i < array.length; i += part) {
+				result.push(Array.prototype.slice.call(array, i, i + part));
+			}
+			return result;
+		}
+	}, {
+		key: 'getAstString',
+		value: function getAstString(source, ast) {
+			var lines = Array.isArray(source) ? source : source.split(/\r?\n/g);
+			var start = ast.loc.start;
+			var end = ast.loc.end;
+			var result = [];
+			result.push(lines[start.line - 1].slice(start.column));
+			for (var i = start.line; i < end.line - 1; i++) {
+				result.push(lines[i]);
+			}
+			result.push(lines[end.line - 1].slice(0, end.column));
+			return result.join('\n');
+		}
+	}, {
+		key: 'allPropertiesOf',
+		value: function allPropertiesOf(obj) {
+			var props = [];
 
-var version = "5.3.0";
+			do {
+				props.push.apply(props, Object.getOwnPropertyNames(obj));
+			} while (obj = Object.getPrototypeOf(obj));
 
-// The main exported interface (under `self.acorn` when in the
-// browser) is a `parse` function that takes a code string and
-// returns an abstract syntax tree as specified by [Mozilla parser
-// API][api].
-//
-// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+			return props;
+		}
+	}]);
 
-function parse(input, options) {
-  return new Parser(options, input).parse()
-}
+	return Utils;
+}(UtilsCore);
 
-// This function tries to parse a single expression at a given
-// offset in a string. Useful for parsing mixed-language formats
-// that embed JavaScript expressions.
+// This ensure static methods are "inherited"
+// See: https://stackoverflow.com/questions/5441508/how-to-inherit-static-methods-from-base-class-in-javascript
 
-function parseExpressionAt(input, pos, options) {
-  var p = new Parser(options, input, pos);
-  p.nextToken();
-  return p.parseExpression()
-}
 
-// Acorn is organized as a tokenizer and a recursive-descent parser.
-// The `tokenizer` export provides an interface to the tokenizer.
+Object.assign(Utils, UtilsCore);
 
-function tokenizer(input, options) {
-  return new Parser(options, input)
-}
+module.exports = Utils;
+},{"../index":76,"./input":72,"./texture":73,"./utils-core":74}],76:[function(require,module,exports){
+'use strict';
 
-// This is a terrible kludge to support the existing, pre-ES6
-// interface where the loose parser module retroactively adds exports
-// to this module.
- // eslint-disable-line camelcase
-function addLooseExports(parse, Parser$$1, plugins$$1) {
-  exports.parse_dammit = parse; // eslint-disable-line camelcase
-  exports.LooseParser = Parser$$1;
-  exports.pluginsLoose = plugins$$1;
-}
+var GPU = require('./core/gpu');
+var alias = require('./core/alias');
+var utils = require('./core/utils');
+var Input = require('./core/input');
+var Texture = require('./core/texture');
 
-exports.version = version;
-exports.parse = parse;
-exports.parseExpressionAt = parseExpressionAt;
-exports.tokenizer = tokenizer;
-exports.addLooseExports = addLooseExports;
-exports.Parser = Parser;
-exports.plugins = plugins;
-exports.defaultOptions = defaultOptions;
-exports.Position = Position;
-exports.SourceLocation = SourceLocation;
-exports.getLineInfo = getLineInfo;
-exports.Node = Node;
-exports.TokenType = TokenType;
-exports.tokTypes = types;
-exports.keywordTypes = keywords$1;
-exports.TokContext = TokContext;
-exports.tokContexts = types$1;
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierStart = isIdentifierStart;
-exports.Token = Token;
-exports.isNewLine = isNewLine;
-exports.lineBreak = lineBreak;
-exports.lineBreakG = lineBreakG;
-exports.nonASCIIwhitespace = nonASCIIwhitespace;
+var CPUFunctionBuilder = require('./backend/cpu/function-builder');
+var CPUFunctionNode = require('./backend/cpu/function-node');
+var CPUKernel = require('./backend/cpu/kernel');
+var CPURunner = require('./backend/cpu/runner');
+
+var WebGLFunctionBuilder = require('./backend/web-gl/function-builder');
+var WebGLFunctionNode = require('./backend/web-gl/function-node');
+var WebGLKernel = require('./backend/web-gl/kernel');
+var WebGLRunner = require('./backend/web-gl/runner');
 
-Object.defineProperty(exports, '__esModule', { value: true });
+GPU.alias = alias;
+GPU.utils = utils;
+GPU.Texture = Texture;
+GPU.Input = Input;
+GPU.input = function (value, size) {
+	return new Input(value, size);
+};
 
-})));
+GPU.CPUFunctionBuilder = CPUFunctionBuilder;
+GPU.CPUFunctionNode = CPUFunctionNode;
+GPU.CPUKernel = CPUKernel;
+GPU.CPURunner = CPURunner;
+
+GPU.WebGLFunctionBuilder = WebGLFunctionBuilder;
+GPU.WebGLFunctionNode = WebGLFunctionNode;
+GPU.WebGLKernel = WebGLKernel;
+GPU.WebGLRunner = WebGLRunner;
 
-},{}],77:[function(require,module,exports){
+if (typeof module !== 'undefined') {
+	module.exports = GPU;
+}
+if (typeof window !== 'undefined') {
+	window.GPU = GPU;
+}
+},{"./backend/cpu/function-builder":51,"./backend/cpu/function-node":52,"./backend/cpu/kernel":54,"./backend/cpu/runner":55,"./backend/web-gl/function-builder":61,"./backend/web-gl/function-node":62,"./backend/web-gl/kernel":64,"./backend/web-gl/runner":65,"./core/alias":69,"./core/gpu":71,"./core/input":72,"./core/texture":73,"./core/utils":75}],77:[function(require,module,exports){
 exports.read = function (buffer, offset, isLE, mLen, nBytes) {
   var e, m
   var eLen = nBytes * 8 - mLen - 1
@@ -18437,7 +18537,7 @@ function forEach(xs, f) {
     f(xs[i], i);
   }
 }
-},{"./_stream_readable":86,"./_stream_writable":88,"core-util-is":48,"inherits":78,"process-nextick-args":81}],85:[function(require,module,exports){
+},{"./_stream_readable":86,"./_stream_writable":88,"core-util-is":49,"inherits":78,"process-nextick-args":81}],85:[function(require,module,exports){
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -18485,7 +18585,7 @@ function PassThrough(options) {
 PassThrough.prototype._transform = function (chunk, encoding, cb) {
   cb(null, chunk);
 };
-},{"./_stream_transform":87,"core-util-is":48,"inherits":78}],86:[function(require,module,exports){
+},{"./_stream_transform":87,"core-util-is":49,"inherits":78}],86:[function(require,module,exports){
 (function (process,global){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -19495,7 +19595,7 @@ function indexOf(xs, x) {
   return -1;
 }
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":84,"./internal/streams/BufferList":89,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":48,"events":49,"inherits":78,"isarray":80,"process-nextick-args":81,"safe-buffer":97,"string_decoder/":92,"util":46}],87:[function(require,module,exports){
+},{"./_stream_duplex":84,"./internal/streams/BufferList":89,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":49,"events":50,"inherits":78,"isarray":80,"process-nextick-args":81,"safe-buffer":96,"string_decoder/":98,"util":47}],87:[function(require,module,exports){
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -19710,7 +19810,7 @@ function done(stream, er, data) {
 
   return stream.push(null);
 }
-},{"./_stream_duplex":84,"core-util-is":48,"inherits":78}],88:[function(require,module,exports){
+},{"./_stream_duplex":84,"core-util-is":49,"inherits":78}],88:[function(require,module,exports){
 (function (process,global){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -20377,7 +20477,7 @@ Writable.prototype._destroy = function (err, cb) {
   cb(err);
 };
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":84,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":48,"inherits":78,"process-nextick-args":81,"safe-buffer":97,"util-deprecate":102}],89:[function(require,module,exports){
+},{"./_stream_duplex":84,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":49,"inherits":78,"process-nextick-args":81,"safe-buffer":96,"util-deprecate":102}],89:[function(require,module,exports){
 'use strict';
 
 /*<replacement>*/
@@ -20452,7 +20552,7 @@ module.exports = function () {
 
   return BufferList;
 }();
-},{"safe-buffer":97}],90:[function(require,module,exports){
+},{"safe-buffer":96}],90:[function(require,module,exports){
 'use strict';
 
 /*<replacement>*/
@@ -20483,52 +20583,263 @@ function destroy(err, cb) {
     this._readableState.destroyed = true;
   }
 
-  // if this is a duplex stream mark the writable part as destroyed as well
-  if (this._writableState) {
-    this._writableState.destroyed = true;
-  }
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+
+  this._destroy(err || null, function (err) {
+    if (!cb && err) {
+      processNextTick(emitErrorNT, _this, err);
+      if (_this._writableState) {
+        _this._writableState.errorEmitted = true;
+      }
+    } else if (cb) {
+      cb(err);
+    }
+  });
+}
+
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+
+module.exports = {
+  destroy: destroy,
+  undestroy: undestroy
+};
+},{"process-nextick-args":81}],91:[function(require,module,exports){
+module.exports = require('events').EventEmitter;
+
+},{"events":50}],92:[function(require,module,exports){
+module.exports = require('./readable').PassThrough
+
+},{"./readable":93}],93:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":84,"./lib/_stream_passthrough.js":85,"./lib/_stream_readable.js":86,"./lib/_stream_transform.js":87,"./lib/_stream_writable.js":88}],94:[function(require,module,exports){
+module.exports = require('./readable').Transform
+
+},{"./readable":93}],95:[function(require,module,exports){
+module.exports = require('./lib/_stream_writable.js');
+
+},{"./lib/_stream_writable.js":88}],96:[function(require,module,exports){
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+  for (var key in src) {
+    dst[key] = src[key]
+  }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+  module.exports = buffer
+} else {
+  // Copy properties from require('buffer')
+  copyProps(buffer, exports)
+  exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+  if (typeof arg === 'number') {
+    throw new TypeError('Argument must not be a number')
+  }
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  var buf = Buffer(size)
+  if (fill !== undefined) {
+    if (typeof encoding === 'string') {
+      buf.fill(fill, encoding)
+    } else {
+      buf.fill(fill)
+    }
+  } else {
+    buf.fill(0)
+  }
+  return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return buffer.SlowBuffer(size)
+}
+
+},{"buffer":48}],97:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('readable-stream/readable.js');
+Stream.Writable = require('readable-stream/writable.js');
+Stream.Duplex = require('readable-stream/duplex.js');
+Stream.Transform = require('readable-stream/transform.js');
+Stream.PassThrough = require('readable-stream/passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams.  Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+  EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+  var source = this;
+
+  function ondata(chunk) {
+    if (dest.writable) {
+      if (false === dest.write(chunk) && source.pause) {
+        source.pause();
+      }
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  var didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      throw er; // Unhandled stream error in pipe.
+    }
+  }
+
+  source.on('error', onerror);
+  dest.on('error', onerror);
+
+  // remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
 
-  this._destroy(err || null, function (err) {
-    if (!cb && err) {
-      processNextTick(emitErrorNT, _this, err);
-      if (_this._writableState) {
-        _this._writableState.errorEmitted = true;
-      }
-    } else if (cb) {
-      cb(err);
-    }
-  });
-}
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
 
-function undestroy() {
-  if (this._readableState) {
-    this._readableState.destroyed = false;
-    this._readableState.reading = false;
-    this._readableState.ended = false;
-    this._readableState.endEmitted = false;
+    dest.removeListener('close', cleanup);
   }
 
-  if (this._writableState) {
-    this._writableState.destroyed = false;
-    this._writableState.ended = false;
-    this._writableState.ending = false;
-    this._writableState.finished = false;
-    this._writableState.errorEmitted = false;
-  }
-}
+  source.on('end', cleanup);
+  source.on('close', cleanup);
 
-function emitErrorNT(self, err) {
-  self.emit('error', err);
-}
+  dest.on('close', cleanup);
 
-module.exports = {
-  destroy: destroy,
-  undestroy: undestroy
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
 };
-},{"process-nextick-args":81}],91:[function(require,module,exports){
-module.exports = require('events').EventEmitter;
 
-},{"events":49}],92:[function(require,module,exports){
+},{"events":50,"inherits":78,"readable-stream/duplex.js":83,"readable-stream/passthrough.js":92,"readable-stream/readable.js":93,"readable-stream/transform.js":94,"readable-stream/writable.js":95}],98:[function(require,module,exports){
 'use strict';
 
 var Buffer = require('safe-buffer').Buffer;
@@ -20801,218 +21112,7 @@ function simpleWrite(buf) {
 function simpleEnd(buf) {
   return buf && buf.length ? this.write(buf) : '';
 }
-},{"safe-buffer":97}],93:[function(require,module,exports){
-module.exports = require('./readable').PassThrough
-
-},{"./readable":94}],94:[function(require,module,exports){
-exports = module.exports = require('./lib/_stream_readable.js');
-exports.Stream = exports;
-exports.Readable = exports;
-exports.Writable = require('./lib/_stream_writable.js');
-exports.Duplex = require('./lib/_stream_duplex.js');
-exports.Transform = require('./lib/_stream_transform.js');
-exports.PassThrough = require('./lib/_stream_passthrough.js');
-
-},{"./lib/_stream_duplex.js":84,"./lib/_stream_passthrough.js":85,"./lib/_stream_readable.js":86,"./lib/_stream_transform.js":87,"./lib/_stream_writable.js":88}],95:[function(require,module,exports){
-module.exports = require('./readable').Transform
-
-},{"./readable":94}],96:[function(require,module,exports){
-module.exports = require('./lib/_stream_writable.js');
-
-},{"./lib/_stream_writable.js":88}],97:[function(require,module,exports){
-/* eslint-disable node/no-deprecated-api */
-var buffer = require('buffer')
-var Buffer = buffer.Buffer
-
-// alternative to using Object.keys for old browsers
-function copyProps (src, dst) {
-  for (var key in src) {
-    dst[key] = src[key]
-  }
-}
-if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
-  module.exports = buffer
-} else {
-  // Copy properties from require('buffer')
-  copyProps(buffer, exports)
-  exports.Buffer = SafeBuffer
-}
-
-function SafeBuffer (arg, encodingOrOffset, length) {
-  return Buffer(arg, encodingOrOffset, length)
-}
-
-// Copy static methods from Buffer
-copyProps(Buffer, SafeBuffer)
-
-SafeBuffer.from = function (arg, encodingOrOffset, length) {
-  if (typeof arg === 'number') {
-    throw new TypeError('Argument must not be a number')
-  }
-  return Buffer(arg, encodingOrOffset, length)
-}
-
-SafeBuffer.alloc = function (size, fill, encoding) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  var buf = Buffer(size)
-  if (fill !== undefined) {
-    if (typeof encoding === 'string') {
-      buf.fill(fill, encoding)
-    } else {
-      buf.fill(fill)
-    }
-  } else {
-    buf.fill(0)
-  }
-  return buf
-}
-
-SafeBuffer.allocUnsafe = function (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  return Buffer(size)
-}
-
-SafeBuffer.allocUnsafeSlow = function (size) {
-  if (typeof size !== 'number') {
-    throw new TypeError('Argument must be a number')
-  }
-  return buffer.SlowBuffer(size)
-}
-
-},{"buffer":47}],98:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-module.exports = Stream;
-
-var EE = require('events').EventEmitter;
-var inherits = require('inherits');
-
-inherits(Stream, EE);
-Stream.Readable = require('readable-stream/readable.js');
-Stream.Writable = require('readable-stream/writable.js');
-Stream.Duplex = require('readable-stream/duplex.js');
-Stream.Transform = require('readable-stream/transform.js');
-Stream.PassThrough = require('readable-stream/passthrough.js');
-
-// Backwards-compat with node 0.4.x
-Stream.Stream = Stream;
-
-
-
-// old-style streams.  Note that the pipe method (the only relevant
-// part of this class) is overridden in the Readable class.
-
-function Stream() {
-  EE.call(this);
-}
-
-Stream.prototype.pipe = function(dest, options) {
-  var source = this;
-
-  function ondata(chunk) {
-    if (dest.writable) {
-      if (false === dest.write(chunk) && source.pause) {
-        source.pause();
-      }
-    }
-  }
-
-  source.on('data', ondata);
-
-  function ondrain() {
-    if (source.readable && source.resume) {
-      source.resume();
-    }
-  }
-
-  dest.on('drain', ondrain);
-
-  // If the 'end' option is not supplied, dest.end() will be called when
-  // source gets the 'end' or 'close' events.  Only dest.end() once.
-  if (!dest._isStdio && (!options || options.end !== false)) {
-    source.on('end', onend);
-    source.on('close', onclose);
-  }
-
-  var didOnEnd = false;
-  function onend() {
-    if (didOnEnd) return;
-    didOnEnd = true;
-
-    dest.end();
-  }
-
-
-  function onclose() {
-    if (didOnEnd) return;
-    didOnEnd = true;
-
-    if (typeof dest.destroy === 'function') dest.destroy();
-  }
-
-  // don't leave dangling pipes when there are errors.
-  function onerror(er) {
-    cleanup();
-    if (EE.listenerCount(this, 'error') === 0) {
-      throw er; // Unhandled stream error in pipe.
-    }
-  }
-
-  source.on('error', onerror);
-  dest.on('error', onerror);
-
-  // remove all the event listeners that were added.
-  function cleanup() {
-    source.removeListener('data', ondata);
-    dest.removeListener('drain', ondrain);
-
-    source.removeListener('end', onend);
-    source.removeListener('close', onclose);
-
-    source.removeListener('error', onerror);
-    dest.removeListener('error', onerror);
-
-    source.removeListener('end', cleanup);
-    source.removeListener('close', cleanup);
-
-    dest.removeListener('close', cleanup);
-  }
-
-  source.on('end', cleanup);
-  source.on('close', cleanup);
-
-  dest.on('close', cleanup);
-
-  dest.emit('pipe', source);
-
-  // Allow for unix-like usage: A.pipe(B).pipe(C)
-  return dest;
-};
-
-},{"events":49,"inherits":78,"readable-stream/duplex.js":83,"readable-stream/passthrough.js":93,"readable-stream/readable.js":94,"readable-stream/transform.js":95,"readable-stream/writable.js":96}],99:[function(require,module,exports){
+},{"safe-buffer":96}],99:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
diff --git a/browser.min.js b/browser.min.js
index 0a064f7bd..05aa40c06 100644
--- a/browser.min.js
+++ b/browser.min.js
@@ -11,6 +11,7 @@
  * acorn:
  *   license: MIT (http://opensource.org/licenses/MIT)
  *   maintainers: Marijn Haverbeke <marijnh@gmail.com>, Ingvar Stepanyan <me@rreverser.com>
+ *   contributors: List of Acorn contributors. Updated before every release., Adrian Heine, Adrian Heine né Lang, Adrian Rakovsky, Alistair Braidwood, Amila Welihinda, Andres Suarez, Angelo, Aparajita Fishman, Arian Stolwijk, Artem Govorov, Bradley Heinz, Brandon Mills, Charles Hughes, Charmander, Conrad Irwin, Daniel Tschinder, David Bonnet, Domenico Matteo, ehmicky, Felix Maier, Forbes Lindesay, Gilad Peleg, impinball, Ingvar Stepanyan, Jackson Ray Hamilton, Jesse McCarthy, Jiaxing Wang, Joel Kemp, Johannes Herr, John-David Dalton, Jordan Klassen, Jürg Lehni, Kai Cataldo, keeyipchan, Keheliya Gallaba, Kevin Irish, Kevin Kwok, krator, laosb, Marek, Marijn Haverbeke, Martin Carlberg, Mat Garcia, Mathias Bynens, Mathieu 'p01' Henri, Matthew Bastien, Max Schaefer, Max Zerzouri, Mihai Bazon, Mike Rennie, naoh, Nicholas C. Zakas, Nick Fitzgerald, Olivier Thomann, Oskar Schöldström, Paul Harper, Peter Rust, PlNG, Prayag Verma, ReadmeCritic, r-e-d, Richard Gibson, Rich Harris, Sebastian McKenzie, Shahar Soel, Simen Bekkhus, Teddy Katz, Timothy Gu, Toru Nagashima, Victor Homyakov, Wexpo Lyu, zsjforcn
  *   homepage: https://github.com/acornjs/acorn
  *   version: 5.3.0
  *
@@ -29,12 +30,14 @@
  *
  * core-util-is:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)
+ *   author: Isaac Z. Schlueter <i@izs.me>
+ *   homepage: https://github.com/isaacs/core-util-is#readme
  *   version: 1.0.2
  *
  * events:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)
+ *   author: Irakli Gozalishvili <rfobic@gmail.com>
+ *   homepage: https://github.com/Gozala/events#readme
  *   version: 1.1.1
  *
  * gpu.js:
@@ -47,10 +50,12 @@
  *   license: BSD-3-Clause (http://opensource.org/licenses/BSD-3-Clause)
  *   author: Feross Aboukhadijeh <feross@feross.org>
  *   contributors: Romain Beauxis <toots@rastageeks.org>
+ *   homepage: https://github.com/feross/ieee754#readme
  *   version: 1.1.8
  *
  * inherits:
  *   license: ISC (http://opensource.org/licenses/ISC)
+ *   homepage: https://github.com/isaacs/inherits#readme
  *   version: 2.0.3
  *
  * isarray:
@@ -62,6 +67,7 @@
  * process:
  *   license: MIT (http://opensource.org/licenses/MIT)
  *   author: Roman Shtylman <shtylman@gmail.com>
+ *   homepage: https://github.com/shtylman/node-process#readme
  *   version: 0.11.10
  *
  * process-nextick-args:
@@ -71,6 +77,7 @@
  *
  * readable-stream:
  *   license: MIT (http://opensource.org/licenses/MIT)
+ *   homepage: https://github.com/nodejs/readable-stream#readme
  *   version: 2.3.3
  *
  * safe-buffer:
@@ -98,7 +105,7 @@
  *
  * util-deprecate:
  *   license: MIT (http://opensource.org/licenses/MIT)
- *   author: Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)
+ *   author: Nathan Rajlich <nathan@tootallnate.net>
  *   homepage: https://github.com/TooTallNate/util-deprecate
  *   version: 1.0.2
  *
@@ -115,8 +122,8 @@
 },{}],4:[function(require,module,exports){
 "use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var e=0,r=Array(t.length);e<t.length;e++)r[e]=t[e];return r}return Array.from(t)}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}function _inherits(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}function weightedSumSigmoid(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return 1/(1+Math.exp(-a))}function weightedSumRelu(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return a<0?0:a}function weightedSumLeakyRelu(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return a<0?0:.01*a}function weightedSumTanh(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return Math.tanh(a)}function calcErrorOutput(t,e){return e[this.thread.x]-t}function calcDeltasSigmoid(t,e){return t*e*(1-e)}function calcDeltasRelu(t,e){return e>0?t:0}function calcDeltasLeakyRelu(t,e){return e>0?t:.01*t}function calcDeltasTanh(t,e){return(1-e*e)*t}function calcError(t,e){for(var r=0,a=0;a<this.constants.size;a++)r+=e[a]*t[a][this.thread.x];return r}function calcChanges(t,e,r,a,u){return a*e[this.thread.y]*r[this.thread.x]+u*t[this.thread.y][this.thread.x]}function addWeights(t,e){return t+e[this.thread.y][this.thread.x]}function addBiases(t,e,r){return t[this.thread.x]+e[this.thread.x]*r}function mse(t){for(var e=0,r=0;r<this.constants.size;r++)e+=Math.pow(t[r],2);return e/this.constants.size}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var r=0;r<e.length;r++){var a=e[r];a.enumerable=a.enumerable||!1,a.configurable=!0,"value"in a&&(a.writable=!0),Object.defineProperty(t,a.key,a)}}return function(e,r,a){return r&&t(e.prototype,r),a&&t(e,a),e}}(),_get=function t(e,r,a){null===e&&(e=Function.prototype);var u=Object.getOwnPropertyDescriptor(e,r);if(void 0===u){var i=Object.getPrototypeOf(e);return null===i?void 0:t(i,r,a)}if("value"in u)return u.value;var s=u.get;if(void 0!==s)return s.call(a)},_neuralNetwork=require("./neural-network"),_neuralNetwork2=_interopRequireDefault(_neuralNetwork),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_gpu=require("gpu.js"),_gpu2=_interopRequireDefault(_gpu),NeuralNetworkGPU=function(t){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,e);var r=_possibleConstructorReturn(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t));return r.forwardPropagate=[],r.backwardPropagate=[],r.changesPropagate=[],r.biasesPropagate=[],r.gpu=new _gpu2.default({mode:t.mode}),r}return _inherits(e,t),_createClass(e,[{key:"initialize",value:function(t){_get(e.prototype.__proto__||Object.getPrototypeOf(e.prototype),"initialize",this).call(this,t),this.buildRunInput(),this.buildCalculateDeltas(),this.buildGetChanges(),this.buildChangeBiases(),this.buildGetMSE()}},{key:"setActivation",value:function(){}},{key:"trainPattern",value:function(t,e,r){return r=r||this.learningRate,this.runInput(t),this.calculateDeltas(e),this.getChanges(r),this.changeBiases(r),this.getMSE(this.errors[this.outputLayer])[0]}},{key:"buildRunInput",value:function(){var t=null;switch(this.activation){case"sigmoid":t=weightedSumSigmoid;break;case"relu":t=weightedSumRelu;break;case"leaky-relu":t=weightedSumLeakyRelu;break;case"tanh":t=weightedSumTanh;break;default:throw new Error("unknown activation "+this.activation)}for(var e=1;e<=this.outputLayer;e++)this.forwardPropagate[e]=this.gpu.createKernel(t,{output:[this.sizes[e]],outputToTexture:!0,constants:{size:this.sizes[e-1]}})}},{key:"runInput",value:function(t){var e=void 0;this.outputs[0]=t;for(var r=1;r<=this.outputLayer;r++)this.outputs[r]=this.forwardPropagate[r](this.weights[r],this.biases[r],t),e=t=this.outputs[r];return e}},{key:"buildCalculateDeltas",value:function(){var t=null;switch(this.activation){case"sigmoid":t=calcDeltasSigmoid;break;case"relu":t=calcDeltasRelu;break;case"leaky-relu":t=calcDeltasLeakyRelu;break;case"tanh":t=calcDeltasTanh;break;default:throw new Error("unknown activation "+this.activation)}for(var e=this.outputLayer;e>0;e--)e===this.outputLayer?this.backwardPropagate[e]=this.gpu.createKernelMap({error:_gpu2.default.alias("calcErrorOutput",calcErrorOutput),deltas:_gpu2.default.alias("calcDeltas",t)},function(e,r){var a=e[this.thread.x];return t(calcErrorOutput(a,r),a)},{output:[this.sizes[e]],outputToTexture:!0}):this.backwardPropagate[e]=this.gpu.createKernelMap({error:_gpu2.default.alias("calcError",calcError),deltas:_gpu2.default.alias("calcDeltas",t)},function(e,r,a){var u=r[this.thread.x];return t(calcError(e,a),u)},{output:[this.sizes[e]],outputToTexture:!0,constants:{size:this.deltas[e+1].length}})}},{key:"calculateDeltas",value:function(t,e){for(var r=this.outputLayer;r>0;r--){var a=void 0;a=r===this.outputLayer?this.backwardPropagate[r](this.outputs[r],t):this.backwardPropagate[r](this.weights[r+1],this.outputs[r],this.deltas[r+1]),this.deltas[r]=a.deltas,this.errors[r]=a.error}}},{key:"buildGetChanges",value:function(){for(var t=1;t<=this.outputLayer;t++)this.changesPropagate[t]=this.gpu.createKernelMap({weights:_gpu2.default.alias("addWeights",addWeights),changes:_gpu2.default.alias("calcChanges",calcChanges)},function(t,e,r,a,u,i){return addWeights(calcChanges(a,e,t,u,i),r)},{output:[this.sizes[t-1],this.sizes[t]],outputToTexture:!0,constants:{size:this.outputs[t-1].length}})}},{key:"getChanges",value:function(t){for(var e=1;e<=this.outputLayer;e++){var r=this.changesPropagate[e](this.outputs[e-1],this.deltas[e],this.weights[e],this.changes[e],t,this.momentum);this.changes[e]=r.changes,this.weights[e]=r.weights}}},{key:"buildChangeBiases",value:function(){for(var t=1;t<=this.outputLayer;t++)this.biasesPropagate[t]=this.gpu.createKernel(addBiases,{output:[this.sizes[t]],outputToTexture:!0})}},{key:"changeBiases",value:function(t){for(var e=1;e<=this.outputLayer;e++)this.biases[e]=this.biasesPropagate[e](this.biases[e],this.deltas[e],t)}},{key:"buildGetMSE",value:function(){this.getMSE=this.gpu.createKernel(mse,{output:[1],constants:{size:this.outputLayer}})}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var e=[].concat(_toConsumableArray(this.runInput(t).toArray(this.gpu)));return this.outputLookup&&(e=_lookup2.default.toHash(this.outputLookup,e)),e}},{key:"formatData",value:function(t){var e=this;if(!Array.isArray(t)){var r=[];r.push(t),t=r}var a=t[0].input;return Array.isArray(a)||a instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var r=_lookup2.default.toArray(e.inputLookup,t.input);return Object.assign({},t,{input:r})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var r=_lookup2.default.toArray(e.outputLookup,t.output);return Object.assign({},t,{output:r})},this)),t}},{key:"toFunction",value:function(){throw new Error("not implemented on NeuralNetworkGPU")}}]),e}(_neuralNetwork2.default);exports.default=NeuralNetworkGPU;
 
-},{"./lookup":3,"./neural-network":5,"gpu.js":75}],5:[function(require,module,exports){
-"use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var e=0,i=Array(t.length);e<t.length;e++)i[e]=t[e];return i}return Array.from(t)}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var i=0;i<e.length;i++){var r=e[i];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(e,i,r){return i&&t(e.prototype,i),r&&t(e,r),e}}(),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_trainStream=require("./train-stream"),_trainStream2=_interopRequireDefault(_trainStream),_max=require("./utilities/max"),_max2=_interopRequireDefault(_max),_mse=require("./utilities/mse"),_mse2=_interopRequireDefault(_mse),_randos=require("./utilities/randos"),_randos2=_interopRequireDefault(_randos),_range=require("./utilities/range"),_range2=_interopRequireDefault(_range),_toArray=require("./utilities/to-array"),_toArray2=_interopRequireDefault(_toArray),_zeros=require("./utilities/zeros"),_zeros2=_interopRequireDefault(_zeros),_thaw=require("thaw.js"),_thaw2=_interopRequireDefault(_thaw),NeuralNetwork=function(){function t(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,t),Object.assign(this,this.constructor.defaults,e),this.hiddenSizes=e.hiddenLayers,this.sizes=null,this.outputLayer=null,this.biases=null,this.weights=null,this.outputs=null,this.deltas=null,this.changes=null,this.errors=null,this.constructor.prototype.hasOwnProperty("runInput")||(this.runInput=null),this.constructor.prototype.hasOwnProperty("calculateDeltas")||(this.calculateDeltas=null)}return _createClass(t,null,[{key:"trainDefaults",get:function(){return{iterations:2e4,errorThresh:.005,log:!1,logPeriod:10,learningRate:.3,callback:null,callbackPeriod:10}}},{key:"defaults",get:function(){return{learningRate:.3,momentum:.1,binaryThresh:.5,hiddenLayers:null,activation:"sigmoid"}}}]),_createClass(t,[{key:"initialize",value:function(t){this.sizes=t,this.outputLayer=this.sizes.length-1,this.biases=[],this.weights=[],this.outputs=[],this.deltas=[],this.changes=[],this.errors=[];for(var e=0;e<=this.outputLayer;e++){var i=this.sizes[e];if(this.deltas[e]=(0,_zeros2.default)(i),this.errors[e]=(0,_zeros2.default)(i),this.outputs[e]=(0,_zeros2.default)(i),e>0){this.biases[e]=(0,_randos2.default)(i),this.weights[e]=new Array(i),this.changes[e]=new Array(i);for(var r=0;r<i;r++){var a=this.sizes[e-1];this.weights[e][r]=(0,_randos2.default)(a),this.changes[e][r]=(0,_zeros2.default)(a)}}}this.setActivation()}},{key:"setActivation",value:function(){switch(this.activation){case"sigmoid":this.runInput=this.runInput||this.runInputSigmoid,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasSigmoid;break;case"relu":this.runInput=this.runInput||this.runInputRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasRelu;break;case"leaky-relu":this.runInput=this.runInput||this.runInputLeakyRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasLeakyRelu;break;case"tanh":this.runInput=this.runInput||this.runInputTanh,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasTanh;break;default:throw new Error("unknown activation "+this.activation)}}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var e=[].concat(_toConsumableArray(this.runInput(t)));return this.outputLookup&&(e=_lookup2.default.toHash(this.outputLookup,e)),e}},{key:"runInputSigmoid",value:function(t){this.outputs[0]=t;for(var e=null,i=1;i<=this.outputLayer;i++){for(var r=0;r<this.sizes[i];r++){for(var a=this.weights[i][r],s=this.biases[i][r],u=0;u<a.length;u++)s+=a[u]*t[u];this.outputs[i][r]=1/(1+Math.exp(-s))}e=t=this.outputs[i]}return e}},{key:"runInputRelu",value:function(t){this.outputs[0]=t;for(var e=null,i=1;i<=this.outputLayer;i++){for(var r=0;r<this.sizes[i];r++){for(var a=this.weights[i][r],s=this.biases[i][r],u=0;u<a.length;u++)s+=a[u]*t[u];this.outputs[i][r]=s<0?0:s}e=t=this.outputs[i]}return e}},{key:"runInputLeakyRelu",value:function(t){this.outputs[0]=t;for(var e=null,i=1;i<=this.outputLayer;i++){for(var r=0;r<this.sizes[i];r++){for(var a=this.weights[i][r],s=this.biases[i][r],u=0;u<a.length;u++)s+=a[u]*t[u];this.outputs[i][r]=s<0?0:.01*s}e=t=this.outputs[i]}return e}},{key:"runInputTanh",value:function(t){this.outputs[0]=t;for(var e=null,i=1;i<=this.outputLayer;i++){for(var r=0;r<this.sizes[i];r++){for(var a=this.weights[i][r],s=this.biases[i][r],u=0;u<a.length;u++)s+=a[u]*t[u];this.outputs[i][r]=Math.tanh(s)}e=t=this.outputs[i]}return e}},{key:"_getSizesFromData",value:function(t){var e=[],i=t[0].input.length,r=t[0].output.length,a=this.hiddenSizes;return a?a.forEach(function(t){e.push(t)}):e.push(Math.max(3,Math.floor(i/2))),e.unshift(i),e.push(r),e}},{key:"_setLogMethod",value:function(t){return!!t&&console.log}},{key:"_calculateTrainingError",value:function(t,e){for(var i=0,r=0;r<t.length;++r)i+=this.trainPattern(t[r].input,t[r].output,e);return i/t.length}},{key:"_checkTrainingTick",value:function(t,e,i){e.iterations++,e.error=this._calculateTrainingError(t,i.learningRate),i.log&&e.iterations%i.logPeriod==0&&i.log("iterations: "+e.iterations+", training error: "+e.error),i.callback&&e.iterations%i.callbackPeriod==0&&i.callback(Object.assign(e))}},{key:"train",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},i=Object.assign({},this.constructor.trainDefaults,e);t=this.formatData(t),i.log=this._setLogMethod(i.log),i.learningRate=e.learningRate||this.learningRate||i.learningRate;var r={error:1,iterations:0};if(null===this.sizes){var a=this._getSizesFromData(t);this.initialize(a)}for(;r.iterations<i.iterations&&r.error>i.errorThresh;)this._checkTrainingTick(t,r,i);return r}},{key:"trainAsync",value:function(t){var e=this,i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return new Promise(function(r,a){var s=Object.assign({},e.constructor.trainDefaults,i);t=e.formatData(t),s.log=e._setLogMethod(s.log),s.learningRate=i.learningRate||e.learningRate||s.learningRate;var u=(Date.now(),s.trainTimeMs,{error:1,iterations:0});if(null===e.sizes){var n=e._getSizesFromData(t);e.initialize(n)}var o=new Array(s.iterations),l=new _thaw2.default(o,{delay:!0,each:function(){e._checkTrainingTick(t,u,s),u.error<s.errorThresh&&l.stop()},done:function(){r(u)}});l.tick()})}},{key:"trainPattern",value:function(t,e,i){return i=i||this.learningRate,this.runInput(t),this.calculateDeltas(e),this.adjustWeights(i),(0,_mse2.default)(this.errors[this.outputLayer])}},{key:"calculateDeltasSigmoid",value:function(t){for(var e=this.outputLayer;e>=0;e--)for(var i=0;i<this.sizes[e];i++){var r=this.outputs[e][i],a=0;if(e===this.outputLayer)a=t[i]-r;else for(var s=this.deltas[e+1],u=0;u<s.length;u++)a+=s[u]*this.weights[e+1][u][i];this.errors[e][i]=a,this.deltas[e][i]=a*r*(1-r)}}},{key:"calculateDeltasRelu",value:function(t){for(var e=this.outputLayer;e>=0;e--)for(var i=0;i<this.sizes[e];i++){var r=this.outputs[e][i],a=0;if(e===this.outputLayer)a=t[i]-r;else for(var s=this.deltas[e+1],u=0;u<s.length;u++)a+=s[u]*this.weights[e+1][u][i];this.errors[e][i]=a,this.deltas[e][i]=r>0?a:0}}},{key:"calculateDeltasLeakyRelu",value:function(t){for(var e=this.outputLayer;e>=0;e--)for(var i=0;i<this.sizes[e];i++){var r=this.outputs[e][i],a=0;if(e===this.outputLayer)a=t[i]-r;else for(var s=this.deltas[e+1],u=0;u<s.length;u++)a+=s[u]*this.weights[e+1][u][i];this.errors[e][i]=a,this.deltas[e][i]=r>0?a:.01*a}}},{key:"calculateDeltasTanh",value:function(t){for(var e=this.outputLayer;e>=0;e--)for(var i=0;i<this.sizes[e];i++){var r=this.outputs[e][i],a=0;if(e===this.outputLayer)a=t[i]-r;else for(var s=this.deltas[e+1],u=0;u<s.length;u++)a+=s[u]*this.weights[e+1][u][i];this.errors[e][i]=a,this.deltas[e][i]=(1-r*r)*a}}},{key:"adjustWeights",value:function(t){for(var e=1;e<=this.outputLayer;e++)for(var i=this.outputs[e-1],r=0;r<this.sizes[e];r++){for(var a=this.deltas[e][r],s=0;s<i.length;s++){var u=this.changes[e][r][s];u=t*a*i[s]+this.momentum*u,this.changes[e][r][s]=u,this.weights[e][r][s]+=u}this.biases[e][r]+=t*a}}},{key:"formatData",value:function(t){var e=this;if(!Array.isArray(t)){var i=[];i.push(t),t=i}var r=t[0].input;return Array.isArray(r)||r instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var i=_lookup2.default.toArray(e.inputLookup,t.input);return Object.assign({},t,{input:i})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var i=_lookup2.default.toArray(e.outputLookup,t.output);return Object.assign({},t,{output:i})},this)),t}},{key:"test",value:function(t){var e=this;t=this.formatData(t);for(var i=1===t[0].output.length,r=0,a=0,s=0,u=0,n=[],o=0,l=0;l<t.length;l++)!function(l){var h=e.runInput(t[l].input),c=t[l].output,p=void 0,f=void 0;if(i?(p=h[0]>e.binaryThresh?1:0,f=c[0]):(p=h.indexOf((0,_max2.default)(h)),f=c.indexOf((0,_max2.default)(c))),p!==f){var v=t[l];Object.assign(v,{actual:p,expected:f}),n.push(v)}i&&(0===p&&0===f?u++:1===p&&1===f?s++:0===p&&1===f?a++:1===p&&0===f&&r++);var g=h.map(function(t,e){return c[e]-t});o+=(0,_mse2.default)(g)}(l);var h=o/t.length,c={error:h,misclasses:n};return i&&Object.assign(c,{trueNeg:u,truePos:s,falseNeg:a,falsePos:r,total:t.length,precision:s/(s+r),recall:s/(s+a),accuracy:(u+s)/t.length}),c}},{key:"toJSON",value:function(){for(var t=[],e=0;e<=this.outputLayer;e++){t[e]={};var i=void 0;i=0===e&&this.inputLookup?Object.keys(this.inputLookup):e===this.outputLayer&&this.outputLookup?Object.keys(this.outputLookup):(0,_range2.default)(0,this.sizes[e]);for(var r=0;r<i.length;r++){var a=i[r];if(t[e][a]={},e>0){t[e][a].bias=this.biases[e][r],t[e][a].weights={};for(var s in t[e-1]){var u=s;1===e&&this.inputLookup&&(u=this.inputLookup[s]),t[e][a].weights[s]=this.weights[e][r][u]}}}}return{sizes:this.sizes,layers:t,outputLookup:!!this.outputLookup,inputLookup:!!this.inputLookup,activation:this.activation}}},{key:"fromJSON",value:function(t){this.initialize(t.sizes);for(var e=0;e<=this.outputLayer;e++){var i=t.layers[e];if(0!==e||i[0]&&!t.inputLookup?e!==this.outputLayer||i[0]&&!t.outputLookup||(this.outputLookup=_lookup2.default.lookupFromHash(i)):this.inputLookup=_lookup2.default.lookupFromHash(i),e>0){var r=Object.keys(i);this.sizes[e]=r.length;for(var a in r){var s=r[a];this.biases[e][a]=i[s].bias,this.weights[e][a]=(0,_toArray2.default)(i[s].weights)}}}return this.setActivation(),this}},{key:"toFunction",value:function(){function t(i,r,a){if(0===r)return"string"==typeof a?"input['"+a+"']":"input["+a+"]";var s=i[r],u=s[a],n=[u.bias];for(var o in u.weights)u.weights[o]<0?n.push(u.weights[o]+"*("+t(i,r-1,o)+")"):n.push("+"+u.weights[o]+"*("+t(i,r-1,o)+")");switch(e){case"sigmoid":return"1/(1+1/Math.exp("+n.join("")+"))";case"relu":return"var sum = "+n.join("")+";(sum < 0 ? 0 : sum);";case"leaky-relu":return"var sum = "+n.join("")+";(sum < 0 ? 0 : 0.01 * sum);";case"tanh":return"Math.tanh("+n.join("")+");";default:throw new Error("unknown activation type "+e)}}var e=this.activation,i=this.toJSON().layers,r=[],a=void 0;for(var s in i[i.length-1])r.push(t(i,i.length-1,s));return a=this.outputLookup?"{"+Object.keys(this.outputLookup).map(function(t,e){return"'"+t+"':"+r[e]})+"}":"["+r.join(",")+"]",new Function("input","return "+a)}},{key:"createTrainStream",value:function(t){return t=t||{},t.neuralNetwork=this,this.setActivation(),this.trainStream=new _trainStream2.default(t),this.trainStream}},{key:"isRunnable",get:function(){var t=this;if(!this.runInput)return console.error("Activation function has not been initialized, did you run train()?"),!1;var e=["sizes","outputLayer","biases","weights","outputs","deltas","changes","errors"].filter(function(e){return null===t[e]});return!(e.length>0)||(console.error("Some settings have not been initialized correctly, did you run train()? Found issues with: "+e.join(", ")),!1)}}]),t}();exports.default=NeuralNetwork;
+},{"./lookup":3,"./neural-network":5,"gpu.js":76}],5:[function(require,module,exports){
+"use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var i=0,e=Array(t.length);i<t.length;i++)e[i]=t[i];return e}return Array.from(t)}function _classCallCheck(t,i){if(!(t instanceof i))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,i){for(var e=0;e<i.length;e++){var r=i[e];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(i,e,r){return e&&t(i.prototype,e),r&&t(i,r),i}}(),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_trainStream=require("./train-stream"),_trainStream2=_interopRequireDefault(_trainStream),_max=require("./utilities/max"),_max2=_interopRequireDefault(_max),_mse=require("./utilities/mse"),_mse2=_interopRequireDefault(_mse),_randos=require("./utilities/randos"),_randos2=_interopRequireDefault(_randos),_range=require("./utilities/range"),_range2=_interopRequireDefault(_range),_toArray=require("./utilities/to-array"),_toArray2=_interopRequireDefault(_toArray),_zeros=require("./utilities/zeros"),_zeros2=_interopRequireDefault(_zeros),_thaw=require("thaw.js"),_thaw2=_interopRequireDefault(_thaw),NeuralNetwork=function(){function t(){var i=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,t),Object.assign(this,this.constructor.defaults,i),this.hiddenSizes=i.hiddenLayers,this.trainOpts={},this.updateTrainingOptions(Object.assign({},this.constructor.trainDefaults,i)),this.sizes=null,this.outputLayer=null,this.biases=null,this.weights=null,this.outputs=null,this.deltas=null,this.changes=null,this.errors=null,this.constructor.prototype.hasOwnProperty("runInput")||(this.runInput=null),this.constructor.prototype.hasOwnProperty("calculateDeltas")||(this.calculateDeltas=null)}return _createClass(t,null,[{key:"trainDefaults",get:function(){return{iterations:2e4,errorThresh:.005,log:!1,logPeriod:10,learningRate:.3,momentum:.1,callback:null,callbackPeriod:10,timeout:1/0}}},{key:"defaults",get:function(){return{binaryThresh:.5,hiddenLayers:[3],activation:"sigmoid"}}}]),_createClass(t,[{key:"_initialize",value:function(){if(!this.sizes)throw new Error("Sizes must be set before initializing");this.outputLayer=this.sizes.length-1,this.biases=[],this.weights=[],this.outputs=[],this.deltas=[],this.changes=[],this.errors=[];for(var t=0;t<=this.outputLayer;t++){var i=this.sizes[t];if(this.deltas[t]=(0,_zeros2.default)(i),this.errors[t]=(0,_zeros2.default)(i),this.outputs[t]=(0,_zeros2.default)(i),t>0){this.biases[t]=(0,_randos2.default)(i),this.weights[t]=new Array(i),this.changes[t]=new Array(i);for(var e=0;e<i;e++){var r=this.sizes[t-1];this.weights[t][e]=(0,_randos2.default)(r),this.changes[t][e]=(0,_zeros2.default)(r)}}}this.setActivation()}},{key:"setActivation",value:function(t){switch(this.activation=t||this.activation,this.activation){case"sigmoid":this.runInput=this.runInput||this.runInputSigmoid,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasSigmoid;break;case"relu":this.runInput=this.runInput||this.runInputRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasRelu;break;case"leaky-relu":this.runInput=this.runInput||this.runInputLeakyRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasLeakyRelu;break;case"tanh":this.runInput=this.runInput||this.runInputTanh,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasTanh;break;default:throw new Error("unknown activation "+this.activation)}}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var i=[].concat(_toConsumableArray(this.runInput(t)));return this.outputLookup&&(i=_lookup2.default.toHash(this.outputLookup,i)),i}},{key:"runInputSigmoid",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=1/(1+Math.exp(-a))}i=t=this.outputs[e]}return i}},{key:"runInputRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:a}i=t=this.outputs[e]}return i}},{key:"runInputLeakyRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:.01*a}i=t=this.outputs[e]}return i}},{key:"runInputTanh",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=Math.tanh(a)}i=t=this.outputs[e]}return i}},{key:"_verifyIsInitialized",value:function(t){var i=this;this.sizes||(this.sizes=[],this.sizes.push(t[0].input.length),this.hiddenSizes?this.hiddenSizes.forEach(function(t){i.sizes.push(t)}):this.sizes.push(Math.max(3,Math.floor(t[0].input.length/2))),this.sizes.push(t[0].output.length),this._initialize())}},{key:"updateTrainingOptions",value:function(t){t.iterations&&(this.trainOpts.iterations=t.iterations),t.errorThresh&&(this.trainOpts.errorThresh=t.errorThresh),t.log&&this._setLogMethod(t.log),t.logPeriod&&(this.trainOpts.logPeriod=t.logPeriod),t.learningRate&&(this.trainOpts.learningRate=t.learningRate),t.momentum&&(this.trainOpts.momentum=t.momentum),t.callback&&(this.trainOpts.callback=t.callback),t.callbackPeriod&&(this.trainOpts.callbackPeriod=t.callbackPeriod),t.timeout&&(this.trainOpts.timeout=t.timeout),t.activation&&(this.activation=t.activation)}},{key:"_getTrainOptsJSON",value:function(){var t={};return this.trainOpts.iterations&&(t.iterations=this.trainOpts.iterations),this.trainOpts.errorThresh&&(t.errorThresh=this.trainOpts.errorThresh),this.trainOpts.logPeriod&&(t.logPeriod=this.trainOpts.logPeriod),this.trainOpts.learningRate&&(t.learningRate=this.trainOpts.learningRate),this.trainOpts.momentum&&(t.momentum=this.trainOpts.momentum),this.trainOpts.callback&&(t.callback=this.trainOpts.callback),this.trainOpts.callbackPeriod&&(t.callbackPeriod=this.trainOpts.callbackPeriod),this.trainOpts.timeout&&(t.timeout=this.trainOpts.timeout),this.trainOpts.log&&(t.log=!0),t}},{key:"_setLogMethod",value:function(t){this.trainOpts.log="function"==typeof t?t:!!t&&console.log}},{key:"_calculateTrainingError",value:function(t){for(var i=0,e=0;e<t.length;++e)i+=this._trainPattern(t[e].input,t[e].output);return i/t.length}},{key:"_trainingTick",value:function(t,i){i.iterations++,i.error=this._calculateTrainingError(t),this.trainOpts.log&&i.iterations%this.trainOpts.logPeriod==0&&this.trainOpts.log("iterations: "+i.iterations+", training error: "+i.error),this.trainOpts.callback&&i.iterations%this.trainOpts.callbackPeriod==0&&this.trainOpts.callback(Object.assign(i))}},{key:"train",value:function(t){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.updateTrainingOptions(i),t=this.formatData(t);var e=Date.now()+this.trainOpts.timeout,r={error:1,iterations:0};for(this._verifyIsInitialized(t);r.iterations<this.trainOpts.iterations&&r.error>this.trainOpts.errorThresh&&Date.now()<e;)this._trainingTick(t,r);return r}},{key:"trainAsync",value:function(t){var i=this,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return new Promise(function(r,s){i.updateTrainingOptions(e),t=i.formatData(t);var a=Date.now()+i.trainOpts.timeout,n={error:1,iterations:0};i._verifyIsInitialized(t);var u=new Array(i.trainOpts.iterations),o=new _thaw2.default(u,{delay:!0,each:function(){i._trainingTick(t,n),(n.error<i.trainOpts.errorThresh||Date.now()>a)&&o.stop()},done:function(){r(n)}});o.tick()})}},{key:"_trainPattern",value:function(t,i){return this.runInput(t),this.calculateDeltas(i),this.adjustWeights(),(0,_mse2.default)(this.errors[this.outputLayer])}},{key:"calculateDeltasSigmoid",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=s*r*(1-r)}}},{key:"calculateDeltasRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:0}}},{key:"calculateDeltasLeakyRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:.01*s}}},{key:"calculateDeltasTanh",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=(1-r*r)*s}}},{key:"adjustWeights",value:function(){for(var t=1;t<=this.outputLayer;t++)for(var i=this.outputs[t-1],e=0;e<this.sizes[t];e++){for(var r=this.deltas[t][e],s=0;s<i.length;s++){var a=this.changes[t][e][s];a=this.trainOpts.learningRate*r*i[s]+this.trainOpts.momentum*a,this.changes[t][e][s]=a,this.weights[t][e][s]+=a}this.biases[t][e]+=this.trainOpts.learningRate*r}}},{key:"formatData",value:function(t){var i=this;if(!Array.isArray(t)){var e=[];e.push(t),t=e}var r=t[0].input;return Array.isArray(r)||r instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.inputLookup,t.input);return Object.assign({},t,{input:e})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.outputLookup,t.output);return Object.assign({},t,{output:e})},this)),t}},{key:"test",value:function(t){var i=this;t=this.formatData(t);for(var e=1===t[0].output.length,r=0,s=0,a=0,n=0,u=[],o=0,h=0;h<t.length;h++)!function(h){var l=i.runInput(t[h].input),p=t[h].output,c=void 0,f=void 0;if(e?(c=l[0]>i.binaryThresh?1:0,f=p[0]):(c=l.indexOf((0,_max2.default)(l)),f=p.indexOf((0,_max2.default)(p))),c!==f){var v=t[h];Object.assign(v,{actual:c,expected:f}),u.push(v)}e&&(0===c&&0===f?n++:1===c&&1===f?a++:0===c&&1===f?s++:1===c&&0===f&&r++);var g=l.map(function(t,i){return p[i]-t});o+=(0,_mse2.default)(g)}(h);var l=o/t.length,p={error:l,misclasses:u};return e&&Object.assign(p,{trueNeg:n,truePos:a,falseNeg:s,falsePos:r,total:t.length,precision:a/(a+r),recall:a/(a+s),accuracy:(n+a)/t.length}),p}},{key:"toJSON",value:function(){for(var t=[],i=0;i<=this.outputLayer;i++){t[i]={};var e=void 0;e=0===i&&this.inputLookup?Object.keys(this.inputLookup):i===this.outputLayer&&this.outputLookup?Object.keys(this.outputLookup):(0,_range2.default)(0,this.sizes[i]);for(var r=0;r<e.length;r++){var s=e[r];if(t[i][s]={},i>0){t[i][s].bias=this.biases[i][r],t[i][s].weights={};for(var a in t[i-1]){var n=a;1===i&&this.inputLookup&&(n=this.inputLookup[a]),t[i][s].weights[a]=this.weights[i][r][n]}}}}return{sizes:this.sizes,layers:t,outputLookup:!!this.outputLookup,inputLookup:!!this.inputLookup,activation:this.activation,trainOpts:this._getTrainOptsJSON()}}},{key:"fromJSON",value:function(t){this.sizes=t.sizes,this._initialize();for(var i=0;i<=this.outputLayer;i++){var e=t.layers[i];if(0!==i||e[0]&&!t.inputLookup?i!==this.outputLayer||e[0]&&!t.outputLookup||(this.outputLookup=_lookup2.default.lookupFromHash(e)):this.inputLookup=_lookup2.default.lookupFromHash(e),i>0){var r=Object.keys(e);this.sizes[i]=r.length;for(var s in r){var a=r[s];this.biases[i][s]=e[a].bias,this.weights[i][s]=(0,_toArray2.default)(e[a].weights)}}}return this.updateTrainingOptions(t.trainOpts),this.setActivation(),this}},{key:"toFunction",value:function(){function t(e,r,s){if(0===r)return"string"==typeof s?"input['"+s+"']":"input["+s+"]";var a=e[r],n=a[s],u=[n.bias];for(var o in n.weights)n.weights[o]<0?u.push(n.weights[o]+"*("+t(e,r-1,o)+")"):u.push("+"+n.weights[o]+"*("+t(e,r-1,o)+")");switch(i){case"sigmoid":return"1/(1+1/Math.exp("+u.join("")+"))";case"relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : sum);";case"leaky-relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : 0.01 * sum);";case"tanh":return"Math.tanh("+u.join("")+");";default:throw new Error("unknown activation type "+i)}}var i=this.activation,e=this.toJSON().layers,r=[],s=void 0;for(var a in e[e.length-1])r.push(t(e,e.length-1,a));return s=this.outputLookup?"{"+Object.keys(this.outputLookup).map(function(t,i){return"'"+t+"':"+r[i]})+"}":"["+r.join(",")+"]",new Function("input","return "+s)}},{key:"createTrainStream",value:function(t){return t=t||{},t.neuralNetwork=this,this.setActivation(),this.trainStream=new _trainStream2.default(t),this.trainStream}},{key:"isRunnable",get:function(){var t=this;if(!this.runInput)return console.error("Activation function has not been initialized, did you run train()?"),!1;var i=["sizes","outputLayer","biases","weights","outputs","deltas","changes","errors"].filter(function(i){return null===t[i]});return!(i.length>0)||(console.error("Some settings have not been initialized correctly, did you run train()? Found issues with: "+i.join(", ")),!1)}}]),t}();exports.default=NeuralNetwork;
 
 },{"./lookup":3,"./train-stream":33,"./utilities/max":35,"./utilities/mse":36,"./utilities/randos":40,"./utilities/range":41,"./utilities/to-array":42,"./utilities/zeros":43,"thaw.js":100}],6:[function(require,module,exports){
 "use strict";function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function e(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(t,r,n){return r&&e(t.prototype,r),n&&e(t,n),t}}(),_matrix=require("./matrix"),_matrix2=_interopRequireDefault(_matrix),_randomMatrix=require("./matrix/random-matrix"),_randomMatrix2=_interopRequireDefault(_randomMatrix),_rnn=require("./rnn"),_rnn2=_interopRequireDefault(_rnn),GRU=function(e){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return _inherits(t,e),_createClass(t,[{key:"getModel",value:function(e,t){return{updateGateInputMatrix:new _randomMatrix2.default(e,t,.08),updateGateHiddenMatrix:new _randomMatrix2.default(e,e,.08),updateGateBias:new _matrix2.default(e,1),resetGateInputMatrix:new _randomMatrix2.default(e,t,.08),resetGateHiddenMatrix:new _randomMatrix2.default(e,e,.08),resetGateBias:new _matrix2.default(e,1),cellWriteInputMatrix:new _randomMatrix2.default(e,t,.08),cellWriteHiddenMatrix:new _randomMatrix2.default(e,e,.08),cellWriteBias:new _matrix2.default(e,1)}}},{key:"getEquation",value:function(e,t,r,n){var a=e.sigmoid.bind(e),i=e.add.bind(e),u=e.multiply.bind(e),o=e.multiplyElement.bind(e),l=e.tanh.bind(e),d=e.allOnes.bind(e),s=e.cloneNegative.bind(e),c=a(i(i(u(n.updateGateInputMatrix,t),u(n.updateGateHiddenMatrix,r)),n.updateGateBias)),f=a(i(i(u(n.resetGateInputMatrix,t),u(n.resetGateHiddenMatrix,r)),n.resetGateBias)),p=l(i(i(u(n.cellWriteInputMatrix,t),u(n.cellWriteHiddenMatrix,o(f,r))),n.cellWriteBias));return i(o(i(d(c.rows,c.columns),s(c)),p),o(r,c))}}]),t}(_rnn2.default);exports.default=GRU;
@@ -202,7 +209,7 @@
 },{"../utilities/data-formatter":34,"../utilities/random":39,"../utilities/zeros":43,"./matrix":14,"./matrix/copy":12,"./matrix/equation":13,"./matrix/max-i":15,"./matrix/random-matrix":21,"./matrix/sample-i":26,"./matrix/softmax":29}],33:[function(require,module,exports){
 "use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var e=0,r=Array(t.length);e<t.length;e++)r[e]=t[e];return r}return Array.from(t)}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}function _inherits(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}function uniques(t){return[].concat(_toConsumableArray(new Set(t)))}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var r=0;r<e.length;r++){var i=e[r];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}return function(e,r,i){return r&&t(e.prototype,r),i&&t(e,i),e}}(),_stream=require("stream"),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),TrainStream=function(t){function e(t){var r;_classCallCheck(this,e);var i=_possibleConstructorReturn(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,{objectMode:!0}));if(t=t||{},!t.neuralNetwork)throw new Error("no neural network specified");return i.neuralNetwork=t.neuralNetwork,i.dataFormatDetermined=!1,i.inputKeys=[],i.outputKeys=[],i.i=0,i.iterations=t.iterations||2e4,i.errorThresh=t.errorThresh||.005,i.log=!!t.log&&("function"==typeof t.log?t.log:console.log),i.logPeriod=t.logPeriod||10,i.callback=t.callback,i.callbackPeriod=t.callbackPeriod||10,i.floodCallback=t.floodCallback,i.doneTrainingCallback=t.doneTrainingCallback,i.size=0,i.count=0,i.sum=0,i.on("finish",i.finishStreamIteration.bind(i)),r=i,_possibleConstructorReturn(i,r)}return _inherits(e,t),_createClass(e,[{key:"_write",value:function(t,e,r){if(!t)return this.emit("finish"),r();if(!this.dataFormatDetermined)return this.size++,this.inputKeys=uniques(this.inputKeys.slice(0).concat(Object.keys(t.input))),this.outputKeys=uniques(this.outputKeys.slice(0).concat(Object.keys(t.output))),this.firstDatum=this.firstDatum||t,r();this.count++;var i=this.neuralNetwork.formatData(t);this.trainDatum(i[0]),r()}},{key:"trainDatum",value:function(t){var e=this.neuralNetwork.trainPattern(t.input,t.output);this.sum+=e}},{key:"finishStreamIteration",value:function(){if(this.dataFormatDetermined&&this.size!==this.count&&this.log("This iteration's data length was different from the first."),!this.dataFormatDetermined){this.neuralNetwork.inputLookup=_lookup2.default.lookupFromArray(this.inputKeys),Array.isArray(this.firstDatum.output)||(this.neuralNetwork.outputLookup=_lookup2.default.lookupFromArray(this.outputKeys));var t=this.neuralNetwork.formatData(this.firstDatum),e=[],r=t[0].input.length,i=t[0].output.length,o=this.hiddenSizes;return o?o.forEach(function(t){e.push(t)}):e.push(Math.max(3,Math.floor(r/2))),e.unshift(r),e.push(i),this.dataFormatDetermined=!0,this.neuralNetwork.initialize(e),void("function"==typeof this.floodCallback&&this.floodCallback())}var n=this.sum/this.size;if(this.log&&this.i%this.logPeriod==0&&this.log("iterations:",this.i,"training error:",n),this.callback&&this.i%this.callbackPeriod==0&&this.callback({error:n,iterations:this.i}),this.sum=0,this.count=0,++this.i<this.iterations&&n>this.errorThresh){if("function"==typeof this.floodCallback)return this.floodCallback()}else if("function"==typeof this.doneTrainingCallback)return this.doneTrainingCallback({error:n,iterations:this.i})}}]),e}(_stream.Writable);exports.default=TrainStream;
 
-},{"./lookup":3,"stream":98}],34:[function(require,module,exports){
+},{"./lookup":3,"stream":97}],34:[function(require,module,exports){
 "use strict";function _toConsumableArray(t){if(Array.isArray(t)){for(var e=0,r=Array(t.length);e<t.length;e++)r[e]=t[e];return r}return Array.from(t)}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var r=0;r<e.length;r++){var a=e[r];a.enumerable=a.enumerable||!1,a.configurable=!0,"value"in a&&(a.writable=!0),Object.defineProperty(t,a.key,a)}}return function(e,r,a){return r&&t(e.prototype,r),a&&t(e,a),e}}(),DataFormatter=function(){function t(e){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;_classCallCheck(this,t),void 0!==e&&(this.values=e,this.indexTable={},this.characterTable={},this.characters=[],this.buildCharactersFromIterable(e),this.buildTables(r))}return _createClass(t,[{key:"buildCharactersFromIterable",value:function(t){for(var e={},r=0,a=t.length;r<a;r++){var n=t[r];if(n.hasOwnProperty("length"))for(var i=0,o=n.length;i<o;i++){var u=n[i];e.hasOwnProperty(u)||(e[u]=!0,this.characters.push(u))}else{var l=t[r];if(e.hasOwnProperty(l))continue;e[r]=!0,this.characters.push(l)}}}},{key:"buildTables",value:function(t){for(var e=this.characters.length,r=0;r<e;r++){var a=this.characters[r];r>=t&&(this.indexTable[a]=r,this.characterTable[r]=a)}}},{key:"toIndexes",value:function(t){for(var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=[],a=this.indexTable,n=0,i=t.length;n<i;n++){var o=t[n],u=a[o];if(void 0===u)throw new Error('unrecognized character "'+o+'"');u<e||r.push(u)}return r}},{key:"toIndexesInputOutput",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0,a=void 0;return a="string"==typeof t?this.toIndexes(t.split("").concat(["stop-input","start-output"]),r):this.toIndexes(t.concat(["stop-input","start-output"]),r),null===e?a:"string"==typeof e?a.concat(this.toIndexes(e.split(""),r)):a.concat(this.toIndexes(e,r))}},{key:"toCharacters",value:function(t){for(var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=[],a=this.characterTable,n=0,i=t.length;n<i;n++){var o=t[n];if(!(o<e)){var u=a[o];if(void 0===u)throw new Error('unrecognized index "'+o+'"');r.push(u)}}return r}},{key:"toString",value:function(t,e){return this.toCharacters(t,e).join("")}},{key:"addInputOutput",value:function(){this.addSpecial("stop-input"),this.addSpecial("start-output")}},{key:"addSpecial",value:function(){for(var t=0;t<arguments.length;t++){var e=arguments[t],r=this.indexTable[e]=this.characters.length;this.characterTable[r]=e,this.characters.push(e)}}},{key:"toFunctionString",value:function(){return"\nvar characterTable = "+JSON.stringify(this.characterTable)+";\nvar indexTable = "+JSON.stringify(this.indexTable)+";\nvar characters = "+JSON.stringify(this.characters)+";\n"+this.toIndexes.toString().replace(/(let|var) indexTable = this[.]indexTable;\n/,"").replace(/this[.]/g,"")+"\n"+this.toIndexesInputOutput.toString().replace(/this[.]/g,"")+"\n"+this.toCharacters.toString().replace(/(let|var) characterTable = this[.]characterTable;\n/g,"").replace(/this[.]/,"")+"\n"}}],[{key:"fromAllPrintable",value:function(e){for(var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:["\n"],a=32;a<=126;a++)r.push(String.fromCharCode(a));return new t(r,e)}},{key:"fromAllPrintableInputOutput",value:function(e){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:["\n"],a=t.fromAllPrintable(e,r);return a.addInputOutput(),a}},{key:"fromStringInputOutput",value:function(e,r){var a,n=(a=String.prototype).concat.apply(a,_toConsumableArray(new Set(e))),i=new t(n,r);return i.addInputOutput(),i}},{key:"fromArrayInputOutput",value:function(e,r){var a=new t(e.filter(function(t,e,r){return r.indexOf(t)===e}).sort(),r);return a.addInputOutput(),a}},{key:"fromString",value:function(e,r){var a;return new t((a=String.prototype).concat.apply(a,_toConsumableArray(new Set(e))),r)}},{key:"fromJSON",value:function(e){var r=new t;return r.indexTable=e.indexTable,r.characterTable=e.characterTable,r.values=e.values,r.characters=e.characters,r}}]),t}();exports.default=DataFormatter;
 
 },{}],35:[function(require,module,exports){
@@ -235,109 +242,111 @@
 },{}],44:[function(require,module,exports){
 var crossValidate=require("./dist/cross-validate").default,likely=require("./dist/likely").default,lookup=require("./dist/lookup").default,NeuralNetwork=require("./dist/neural-network").default,NeuralNetworkGPU=require("./dist/neural-network-gpu").default,TrainStream=require("./dist/train-stream").default,RNN=require("./dist/recurrent/rnn").default,LSTM=require("./dist/recurrent/lstm").default,GRU=require("./dist/recurrent/gru").default,utilities={max:require("./dist/utilities/max").default,mse:require("./dist/utilities/mse").default,ones:require("./dist/utilities/ones").default,random:require("./dist/utilities/random").default,randomWeight:require("./dist/utilities/random-weight").default,randos:require("./dist/utilities/randos").default,range:require("./dist/utilities/range").default,toArray:require("./dist/utilities/to-array").default,DataFormatter:require("./dist/utilities/data-formatter").default,zeros:require("./dist/utilities/zeros").default},brain={crossValidate:crossValidate,likely:likely,lookup:lookup,NeuralNetwork:NeuralNetwork,NeuralNetworkGPU:NeuralNetworkGPU,TrainStream:TrainStream,recurrent:{RNN:RNN,LSTM:LSTM,GRU:GRU},utilities:utilities};"undefined"!=typeof window?window.brain=brain:module.exports=brain;
 },{"./dist/cross-validate":1,"./dist/likely":2,"./dist/lookup":3,"./dist/neural-network":5,"./dist/neural-network-gpu":4,"./dist/recurrent/gru":6,"./dist/recurrent/lstm":7,"./dist/recurrent/rnn":32,"./dist/train-stream":33,"./dist/utilities/data-formatter":34,"./dist/utilities/max":35,"./dist/utilities/mse":36,"./dist/utilities/ones":37,"./dist/utilities/random":39,"./dist/utilities/random-weight":38,"./dist/utilities/randos":40,"./dist/utilities/range":41,"./dist/utilities/to-array":42,"./dist/utilities/zeros":43}],45:[function(require,module,exports){
-"use strict";function placeHoldersCount(o){var r=o.length;if(r%4>0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===o[r-2]?2:"="===o[r-1]?1:0}function byteLength(o){return 3*o.length/4-placeHoldersCount(o)}function toByteArray(o){var r,e,t,u,n,p=o.length;u=placeHoldersCount(o),n=new Arr(3*p/4-u),e=u>0?p-4:p;var a=0;for(r=0;r<e;r+=4)t=revLookup[o.charCodeAt(r)]<<18|revLookup[o.charCodeAt(r+1)]<<12|revLookup[o.charCodeAt(r+2)]<<6|revLookup[o.charCodeAt(r+3)],n[a++]=t>>16&255,n[a++]=t>>8&255,n[a++]=255&t;return 2===u?(t=revLookup[o.charCodeAt(r)]<<2|revLookup[o.charCodeAt(r+1)]>>4,n[a++]=255&t):1===u&&(t=revLookup[o.charCodeAt(r)]<<10|revLookup[o.charCodeAt(r+1)]<<4|revLookup[o.charCodeAt(r+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t),n}function tripletToBase64(o){return lookup[o>>18&63]+lookup[o>>12&63]+lookup[o>>6&63]+lookup[63&o]}function encodeChunk(o,r,e){for(var t,u=[],n=r;n<e;n+=3)t=(o[n]<<16)+(o[n+1]<<8)+o[n+2],u.push(tripletToBase64(t));return u.join("")}function fromByteArray(o){for(var r,e=o.length,t=e%3,u="",n=[],p=0,a=e-t;p<a;p+=16383)n.push(encodeChunk(o,p,p+16383>a?a:p+16383));return 1===t?(r=o[e-1],u+=lookup[r>>2],u+=lookup[r<<4&63],u+="=="):2===t&&(r=(o[e-2]<<8)+o[e-1],u+=lookup[r>>10],u+=lookup[r>>4&63],u+=lookup[r<<2&63],u+="="),n.push(u),n.join("")}exports.byteLength=byteLength,exports.toByteArray=toByteArray,exports.fromByteArray=fromByteArray;for(var lookup=[],revLookup=[],Arr="undefined"!=typeof Uint8Array?Uint8Array:Array,code="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,len=code.length;i<len;++i)lookup[i]=code[i],revLookup[code.charCodeAt(i)]=i;revLookup["-".charCodeAt(0)]=62,revLookup["_".charCodeAt(0)]=63;
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e(t.acorn={})}(this,function(t){"use strict";function e(t,e){for(var s=65536,i=0;i<e.length;i+=2){if((s+=e[i])>t)return!1;if((s+=e[i+1])>=t)return!0}}function s(t,s){return t<65?36===t:t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&C.test(String.fromCharCode(t)):!1!==s&&e(t,_)))}function i(t,s){return t<48?36===t:t<58||!(t<65)&&(t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&L.test(String.fromCharCode(t)):!1!==s&&(e(t,_)||e(t,P)))))}function r(t,e){return new T(t,{beforeExpr:!0,binop:e})}function n(t,e){return void 0===e&&(e={}),e.keyword=t,R[t]=new T(t,e)}function a(t){return 10===t||13===t||8232===t||8233===t}function o(t,e){return q.call(t,e)}function h(t,e){for(var s=1,i=0;;){D.lastIndex=i;var r=D.exec(t);if(!(r&&r.index<e))return new j(s,e-i);++s,i=r.index+r[0].length}}function p(t){var e={};for(var s in G)e[s]=t&&o(t,s)?t[s]:G[s];if(e.ecmaVersion>=2015&&(e.ecmaVersion-=2009),null==e.allowReserved&&(e.allowReserved=e.ecmaVersion<5),z(e.onToken)){var i=e.onToken;e.onToken=function(t){return i.push(t)}}return z(e.onComment)&&(e.onComment=c(e,e.onComment)),e}function c(t,e){return function(s,i,r,n,a,o){var h={type:s?"Block":"Line",value:i,start:r,end:n};t.locations&&(h.loc=new W(this,a,o)),t.ranges&&(h.range=[r,n]),e.push(h)}}function l(t){return new RegExp("^(?:"+t.replace(/ /g,"|")+")$")}function u(){this.shorthandAssign=this.trailingComma=this.parenthesizedAssign=this.parenthesizedBind=this.doubleProto=-1}function d(t,e,s,i){return t.type=e,t.end=s,this.options.locations&&(t.loc.end=i),this.options.ranges&&(t.range[1]=s),t}function f(t,e,s,i){try{return new RegExp(t,e)}catch(t){if(void 0!==s)throw t instanceof SyntaxError&&i.raise(s,"Error parsing regular expression: "+t.message),t}}function m(t){return t<=65535?String.fromCharCode(t):(t-=65536,String.fromCharCode(55296+(t>>10),56320+(1023&t)))}function x(t,e){return new $(e,t).parse()}function y(t,e,s){var i=new $(s,t,e);return i.nextToken(),i.parseExpression()}function v(t,e){return new $(e,t)}function b(e,s,i){t.parse_dammit=e,t.LooseParser=s,t.pluginsLoose=i}var g={3:"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",5:"class enum extends super const export import",6:"enum",strict:"implements interface let package private protected public static yield",strictBind:"eval arguments"},k="break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this",w={5:k,6:k+" const class extends export import super"},E=/^in(stanceof)?$/,A="ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢴࢶ-ࢽऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞮꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ",S="‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣔ-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿",C=new RegExp("["+A+"]"),L=new RegExp("["+A+S+"]");A=S=null;var _=[0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541],P=[509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239],T=function(t,e){void 0===e&&(e={}),this.label=t,this.keyword=e.keyword,this.beforeExpr=!!e.beforeExpr,this.startsExpr=!!e.startsExpr,this.isLoop=!!e.isLoop,this.isAssign=!!e.isAssign,this.prefix=!!e.prefix,this.postfix=!!e.postfix,this.binop=e.binop||null,this.updateContext=null},N={beforeExpr:!0},I={startsExpr:!0},R={},V={num:new T("num",I),regexp:new T("regexp",I),string:new T("string",I),name:new T("name",I),eof:new T("eof"),bracketL:new T("[",{beforeExpr:!0,startsExpr:!0}),bracketR:new T("]"),braceL:new T("{",{beforeExpr:!0,startsExpr:!0}),braceR:new T("}"),parenL:new T("(",{beforeExpr:!0,startsExpr:!0}),parenR:new T(")"),comma:new T(",",N),semi:new T(";",N),colon:new T(":",N),dot:new T("."),question:new T("?",N),arrow:new T("=>",N),template:new T("template"),invalidTemplate:new T("invalidTemplate"),ellipsis:new T("...",N),backQuote:new T("`",I),dollarBraceL:new T("${",{beforeExpr:!0,startsExpr:!0}),eq:new T("=",{beforeExpr:!0,isAssign:!0}),assign:new T("_=",{beforeExpr:!0,isAssign:!0}),incDec:new T("++/--",{prefix:!0,postfix:!0,startsExpr:!0}),prefix:new T("!/~",{beforeExpr:!0,prefix:!0,startsExpr:!0}),logicalOR:r("||",1),logicalAND:r("&&",2),bitwiseOR:r("|",3),bitwiseXOR:r("^",4),bitwiseAND:r("&",5),equality:r("==/!=/===/!==",6),relational:r("</>/<=/>=",7),bitShift:r("<</>>/>>>",8),plusMin:new T("+/-",{beforeExpr:!0,binop:9,prefix:!0,startsExpr:!0}),modulo:r("%",10),star:r("*",10),slash:r("/",10),starstar:new T("**",{beforeExpr:!0}),_break:n("break"),_case:n("case",N),_catch:n("catch"),_continue:n("continue"),_debugger:n("debugger"),_default:n("default",N),_do:n("do",{isLoop:!0,beforeExpr:!0}),_else:n("else",N),_finally:n("finally"),_for:n("for",{isLoop:!0}),_function:n("function",I),_if:n("if"),_return:n("return",N),_switch:n("switch"),_throw:n("throw",N),_try:n("try"),_var:n("var"),_const:n("const"),_while:n("while",{isLoop:!0}),_with:n("with"),_new:n("new",{beforeExpr:!0,startsExpr:!0}),_this:n("this",I),_super:n("super",I),_class:n("class",I),_extends:n("extends",N),_export:n("export"),_import:n("import"),_null:n("null",I),_true:n("true",I),_false:n("false",I),_in:n("in",{beforeExpr:!0,binop:7}),_instanceof:n("instanceof",{beforeExpr:!0,binop:7}),_typeof:n("typeof",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_void:n("void",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_delete:n("delete",{beforeExpr:!0,prefix:!0,startsExpr:!0})},F=/\r\n?|\n|\u2028|\u2029/,D=new RegExp(F.source,"g"),B=/[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/,O=/(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g,M=Object.prototype,q=M.hasOwnProperty,U=M.toString,z=Array.isArray||function(t){return"[object Array]"===U.call(t)},j=function(t,e){this.line=t,this.column=e};j.prototype.offset=function(t){return new j(this.line,this.column+t)};var W=function(t,e,s){this.start=e,this.end=s,null!==t.sourceFile&&(this.source=t.sourceFile)},G={ecmaVersion:7,sourceType:"script",onInsertedSemicolon:null,onTrailingComma:null,allowReserved:null,allowReturnOutsideFunction:!1,allowImportExportEverywhere:!1,allowHashBang:!1,locations:!1,onToken:null,onComment:null,ranges:!1,program:null,sourceFile:null,directSourceFile:null,preserveParens:!1,plugins:{}},Y={},$=function(t,e,s){this.options=t=p(t),this.sourceFile=t.sourceFile,this.keywords=l(w[t.ecmaVersion>=6?6:5]);var i="";if(!t.allowReserved){for(var r=t.ecmaVersion;!(i=g[r]);r--);"module"==t.sourceType&&(i+=" await")}this.reservedWords=l(i);var n=(i?i+" ":"")+g.strict;this.reservedWordsStrict=l(n),this.reservedWordsStrictBind=l(n+" "+g.strictBind),this.input=String(e),this.containsEsc=!1,this.loadPlugins(t.plugins),s?(this.pos=s,this.lineStart=this.input.lastIndexOf("\n",s-1)+1,this.curLine=this.input.slice(0,this.lineStart).split(F).length):(this.pos=this.lineStart=0,this.curLine=1),this.type=V.eof,this.value=null,this.start=this.end=this.pos,this.startLoc=this.endLoc=this.curPosition(),this.lastTokEndLoc=this.lastTokStartLoc=null,this.lastTokStart=this.lastTokEnd=this.pos,this.context=this.initialContext(),this.exprAllowed=!0,this.inModule="module"===t.sourceType,this.strict=this.inModule||this.strictDirective(this.pos),this.potentialArrowAt=-1,this.inFunction=this.inGenerator=this.inAsync=!1,this.yieldPos=this.awaitPos=0,this.labels=[],0===this.pos&&t.allowHashBang&&"#!"===this.input.slice(0,2)&&this.skipLineComment(2),this.scopeStack=[],this.enterFunctionScope()};$.prototype.isKeyword=function(t){return this.keywords.test(t)},$.prototype.isReservedWord=function(t){return this.reservedWords.test(t)},$.prototype.extend=function(t,e){this[t]=e(this[t])},$.prototype.loadPlugins=function(t){var e=this;for(var s in t){var i=Y[s];if(!i)throw new Error("Plugin '"+s+"' not found");i(e,t[s])}},$.prototype.parse=function(){var t=this.options.program||this.startNode();return this.nextToken(),this.parseTopLevel(t)};var Q=$.prototype,H=/^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;Q.strictDirective=function(t){for(var e=this;;){O.lastIndex=t,t+=O.exec(e.input)[0].length;var s=H.exec(e.input.slice(t));if(!s)return!1;if("use strict"==(s[1]||s[2]))return!0;t+=s[0].length}},Q.eat=function(t){return this.type===t&&(this.next(),!0)},Q.isContextual=function(t){return this.type===V.name&&this.value===t&&!this.containsEsc},Q.eatContextual=function(t){return!!this.isContextual(t)&&(this.next(),!0)},Q.expectContextual=function(t){this.eatContextual(t)||this.unexpected()},Q.canInsertSemicolon=function(){return this.type===V.eof||this.type===V.braceR||F.test(this.input.slice(this.lastTokEnd,this.start))},Q.insertSemicolon=function(){if(this.canInsertSemicolon())return this.options.onInsertedSemicolon&&this.options.onInsertedSemicolon(this.lastTokEnd,this.lastTokEndLoc),!0},Q.semicolon=function(){this.eat(V.semi)||this.insertSemicolon()||this.unexpected()},Q.afterTrailingComma=function(t,e){if(this.type==t)return this.options.onTrailingComma&&this.options.onTrailingComma(this.lastTokStart,this.lastTokStartLoc),e||this.next(),!0},Q.expect=function(t){this.eat(t)||this.unexpected()},Q.unexpected=function(t){this.raise(null!=t?t:this.start,"Unexpected token")},Q.checkPatternErrors=function(t,e){if(t){t.trailingComma>-1&&this.raiseRecoverable(t.trailingComma,"Comma is not permitted after the rest element");var s=e?t.parenthesizedAssign:t.parenthesizedBind;s>-1&&this.raiseRecoverable(s,"Parenthesized pattern")}},Q.checkExpressionErrors=function(t,e){if(!t)return!1;var s=t.shorthandAssign,i=t.doubleProto;if(!e)return s>=0||i>=0;s>=0&&this.raise(s,"Shorthand property assignments are valid only in destructuring patterns"),i>=0&&this.raiseRecoverable(i,"Redefinition of __proto__ property")},Q.checkYieldAwaitInDefaultParams=function(){this.yieldPos&&(!this.awaitPos||this.yieldPos<this.awaitPos)&&this.raise(this.yieldPos,"Yield expression cannot be a default value"),this.awaitPos&&this.raise(this.awaitPos,"Await expression cannot be a default value")},Q.isSimpleAssignTarget=function(t){return"ParenthesizedExpression"===t.type?this.isSimpleAssignTarget(t.expression):"Identifier"===t.type||"MemberExpression"===t.type};var X=$.prototype;X.parseTopLevel=function(t){var e=this,s={};for(t.body||(t.body=[]);this.type!==V.eof;){var i=e.parseStatement(!0,!0,s);t.body.push(i)}return this.adaptDirectivePrologue(t.body),this.next(),this.options.ecmaVersion>=6&&(t.sourceType=this.options.sourceType),this.finishNode(t,"Program")};var K={kind:"loop"},J={kind:"switch"};X.isLet=function(){if(this.options.ecmaVersion<6||!this.isContextual("let"))return!1;O.lastIndex=this.pos;var t=O.exec(this.input),e=this.pos+t[0].length,r=this.input.charCodeAt(e);if(91===r||123==r)return!0;if(s(r,!0)){for(var n=e+1;i(this.input.charCodeAt(n),!0);)++n;var a=this.input.slice(e,n);if(!E.test(a))return!0}return!1},X.isAsyncFunction=function(){if(this.options.ecmaVersion<8||!this.isContextual("async"))return!1;O.lastIndex=this.pos;var t=O.exec(this.input),e=this.pos+t[0].length;return!(F.test(this.input.slice(this.pos,e))||"function"!==this.input.slice(e,e+8)||e+8!=this.input.length&&i(this.input.charAt(e+8)))},X.parseStatement=function(t,e,s){var i,r=this.type,n=this.startNode();switch(this.isLet()&&(r=V._var,i="let"),r){case V._break:case V._continue:return this.parseBreakContinueStatement(n,r.keyword);case V._debugger:return this.parseDebuggerStatement(n);case V._do:return this.parseDoStatement(n);case V._for:return this.parseForStatement(n);case V._function:return!t&&this.options.ecmaVersion>=6&&this.unexpected(),this.parseFunctionStatement(n,!1);case V._class:return t||this.unexpected(),this.parseClass(n,!0);case V._if:return this.parseIfStatement(n);case V._return:return this.parseReturnStatement(n);case V._switch:return this.parseSwitchStatement(n);case V._throw:return this.parseThrowStatement(n);case V._try:return this.parseTryStatement(n);case V._const:case V._var:return i=i||this.value,t||"var"==i||this.unexpected(),this.parseVarStatement(n,i);case V._while:return this.parseWhileStatement(n);case V._with:return this.parseWithStatement(n);case V.braceL:return this.parseBlock();case V.semi:return this.parseEmptyStatement(n);case V._export:case V._import:return this.options.allowImportExportEverywhere||(e||this.raise(this.start,"'import' and 'export' may only appear at the top level"),this.inModule||this.raise(this.start,"'import' and 'export' may appear only with 'sourceType: module'")),r===V._import?this.parseImport(n):this.parseExport(n,s);default:if(this.isAsyncFunction())return t||this.unexpected(),this.next(),this.parseFunctionStatement(n,!0);var a=this.value,o=this.parseExpression();return r===V.name&&"Identifier"===o.type&&this.eat(V.colon)?this.parseLabeledStatement(n,a,o):this.parseExpressionStatement(n,o)}},X.parseBreakContinueStatement=function(t,e){var s=this,i="break"==e;this.next(),this.eat(V.semi)||this.insertSemicolon()?t.label=null:this.type!==V.name?this.unexpected():(t.label=this.parseIdent(),this.semicolon());for(var r=0;r<this.labels.length;++r){var n=s.labels[r];if(null==t.label||n.name===t.label.name){if(null!=n.kind&&(i||"loop"===n.kind))break;if(t.label&&i)break}}return r===this.labels.length&&this.raise(t.start,"Unsyntactic "+e),this.finishNode(t,i?"BreakStatement":"ContinueStatement")},X.parseDebuggerStatement=function(t){return this.next(),this.semicolon(),this.finishNode(t,"DebuggerStatement")},X.parseDoStatement=function(t){return this.next(),this.labels.push(K),t.body=this.parseStatement(!1),this.labels.pop(),this.expect(V._while),t.test=this.parseParenExpression(),this.options.ecmaVersion>=6?this.eat(V.semi):this.semicolon(),this.finishNode(t,"DoWhileStatement")},X.parseForStatement=function(t){if(this.next(),this.labels.push(K),this.enterLexicalScope(),this.expect(V.parenL),this.type===V.semi)return this.parseFor(t,null);var e=this.isLet();if(this.type===V._var||this.type===V._const||e){var s=this.startNode(),i=e?"let":this.value;return this.next(),this.parseVar(s,!0,i),this.finishNode(s,"VariableDeclaration"),!(this.type===V._in||this.options.ecmaVersion>=6&&this.isContextual("of"))||1!==s.declarations.length||"var"!==i&&s.declarations[0].init?this.parseFor(t,s):this.parseForIn(t,s)}var r=new u,n=this.parseExpression(!0,r);return this.type===V._in||this.options.ecmaVersion>=6&&this.isContextual("of")?(this.toAssignable(n,!1,r),this.checkLVal(n),this.parseForIn(t,n)):(this.checkExpressionErrors(r,!0),this.parseFor(t,n))},X.parseFunctionStatement=function(t,e){return this.next(),this.parseFunction(t,!0,!1,e)},X.parseIfStatement=function(t){return this.next(),t.test=this.parseParenExpression(),t.consequent=this.parseStatement(!this.strict&&this.type==V._function),t.alternate=this.eat(V._else)?this.parseStatement(!this.strict&&this.type==V._function):null,this.finishNode(t,"IfStatement")},X.parseReturnStatement=function(t){return this.inFunction||this.options.allowReturnOutsideFunction||this.raise(this.start,"'return' outside of function"),this.next(),this.eat(V.semi)||this.insertSemicolon()?t.argument=null:(t.argument=this.parseExpression(),this.semicolon()),this.finishNode(t,"ReturnStatement")},X.parseSwitchStatement=function(t){var e=this;this.next(),t.discriminant=this.parseParenExpression(),t.cases=[],this.expect(V.braceL),this.labels.push(J),this.enterLexicalScope();for(var s,i=!1;this.type!=V.braceR;)if(e.type===V._case||e.type===V._default){var r=e.type===V._case;s&&e.finishNode(s,"SwitchCase"),t.cases.push(s=e.startNode()),s.consequent=[],e.next(),r?s.test=e.parseExpression():(i&&e.raiseRecoverable(e.lastTokStart,"Multiple default clauses"),i=!0,s.test=null),e.expect(V.colon)}else s||e.unexpected(),s.consequent.push(e.parseStatement(!0));return this.exitLexicalScope(),s&&this.finishNode(s,"SwitchCase"),this.next(),this.labels.pop(),this.finishNode(t,"SwitchStatement")},X.parseThrowStatement=function(t){return this.next(),F.test(this.input.slice(this.lastTokEnd,this.start))&&this.raise(this.lastTokEnd,"Illegal newline after throw"),t.argument=this.parseExpression(),this.semicolon(),this.finishNode(t,"ThrowStatement")};var Z=[];X.parseTryStatement=function(t){if(this.next(),t.block=this.parseBlock(),t.handler=null,this.type===V._catch){var e=this.startNode();this.next(),this.expect(V.parenL),e.param=this.parseBindingAtom(),this.enterLexicalScope(),this.checkLVal(e.param,"let"),this.expect(V.parenR),e.body=this.parseBlock(!1),this.exitLexicalScope(),t.handler=this.finishNode(e,"CatchClause")}return t.finalizer=this.eat(V._finally)?this.parseBlock():null,t.handler||t.finalizer||this.raise(t.start,"Missing catch or finally clause"),this.finishNode(t,"TryStatement")},X.parseVarStatement=function(t,e){return this.next(),this.parseVar(t,!1,e),this.semicolon(),this.finishNode(t,"VariableDeclaration")},X.parseWhileStatement=function(t){return this.next(),t.test=this.parseParenExpression(),this.labels.push(K),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"WhileStatement")},X.parseWithStatement=function(t){return this.strict&&this.raise(this.start,"'with' in strict mode"),this.next(),t.object=this.parseParenExpression(),t.body=this.parseStatement(!1),this.finishNode(t,"WithStatement")},X.parseEmptyStatement=function(t){return this.next(),this.finishNode(t,"EmptyStatement")},X.parseLabeledStatement=function(t,e,s){for(var i=this,r=0,n=i.labels;r<n.length;r+=1){n[r].name===e&&i.raise(s.start,"Label '"+e+"' is already declared")}for(var a=this.type.isLoop?"loop":this.type===V._switch?"switch":null,o=this.labels.length-1;o>=0;o--){var h=i.labels[o];if(h.statementStart!=t.start)break;h.statementStart=i.start,h.kind=a}return this.labels.push({name:e,kind:a,statementStart:this.start}),t.body=this.parseStatement(!0),("ClassDeclaration"==t.body.type||"VariableDeclaration"==t.body.type&&"var"!=t.body.kind||"FunctionDeclaration"==t.body.type&&(this.strict||t.body.generator))&&this.raiseRecoverable(t.body.start,"Invalid labeled declaration"),this.labels.pop(),t.label=s,this.finishNode(t,"LabeledStatement")},X.parseExpressionStatement=function(t,e){return t.expression=e,this.semicolon(),this.finishNode(t,"ExpressionStatement")},X.parseBlock=function(t){var e=this;void 0===t&&(t=!0);var s=this.startNode();for(s.body=[],this.expect(V.braceL),t&&this.enterLexicalScope();!this.eat(V.braceR);){var i=e.parseStatement(!0);s.body.push(i)}return t&&this.exitLexicalScope(),this.finishNode(s,"BlockStatement")},X.parseFor=function(t,e){return t.init=e,this.expect(V.semi),t.test=this.type===V.semi?null:this.parseExpression(),this.expect(V.semi),t.update=this.type===V.parenR?null:this.parseExpression(),this.expect(V.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"ForStatement")},X.parseForIn=function(t,e){var s=this.type===V._in?"ForInStatement":"ForOfStatement";return this.next(),"ForInStatement"==s&&("AssignmentPattern"===e.type||"VariableDeclaration"===e.type&&null!=e.declarations[0].init&&(this.strict||"Identifier"!==e.declarations[0].id.type))&&this.raise(e.start,"Invalid assignment in for-in loop head"),t.left=e,t.right="ForInStatement"==s?this.parseExpression():this.parseMaybeAssign(),this.expect(V.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,s)},X.parseVar=function(t,e,s){var i=this;for(t.declarations=[],t.kind=s;;){var r=i.startNode();if(i.parseVarId(r,s),i.eat(V.eq)?r.init=i.parseMaybeAssign(e):"const"!==s||i.type===V._in||i.options.ecmaVersion>=6&&i.isContextual("of")?"Identifier"==r.id.type||e&&(i.type===V._in||i.isContextual("of"))?r.init=null:i.raise(i.lastTokEnd,"Complex binding patterns require an initialization value"):i.unexpected(),t.declarations.push(i.finishNode(r,"VariableDeclarator")),!i.eat(V.comma))break}return t},X.parseVarId=function(t,e){t.id=this.parseBindingAtom(e),this.checkLVal(t.id,e,!1)},X.parseFunction=function(t,e,s,i){this.initFunction(t),this.options.ecmaVersion>=6&&!i&&(t.generator=this.eat(V.star)),this.options.ecmaVersion>=8&&(t.async=!!i),e&&(t.id="nullableID"===e&&this.type!=V.name?null:this.parseIdent(),t.id&&this.checkLVal(t.id,"var"));var r=this.inGenerator,n=this.inAsync,a=this.yieldPos,o=this.awaitPos,h=this.inFunction;return this.inGenerator=t.generator,this.inAsync=t.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,this.enterFunctionScope(),e||(t.id=this.type==V.name?this.parseIdent():null),this.parseFunctionParams(t),this.parseFunctionBody(t,s),this.inGenerator=r,this.inAsync=n,this.yieldPos=a,this.awaitPos=o,this.inFunction=h,this.finishNode(t,e?"FunctionDeclaration":"FunctionExpression")},X.parseFunctionParams=function(t){this.expect(V.parenL),t.params=this.parseBindingList(V.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams()},X.parseClass=function(t,e){var s=this;this.next(),this.parseClassId(t,e),this.parseClassSuper(t);var i=this.startNode(),r=!1;for(i.body=[],this.expect(V.braceL);!this.eat(V.braceR);){var n=s.parseClassMember(i);n&&"MethodDefinition"===n.type&&"constructor"===n.kind&&(r&&s.raise(n.start,"Duplicate constructor in the same class"),r=!0)}return t.body=this.finishNode(i,"ClassBody"),this.finishNode(t,e?"ClassDeclaration":"ClassExpression")},X.parseClassMember=function(t){var e=this;if(this.eat(V.semi))return null;var s=this.startNode(),i=function(t,i){void 0===i&&(i=!1);var r=e.start,n=e.startLoc;return!!e.eatContextual(t)&&(!(e.type===V.parenL||i&&e.canInsertSemicolon())||(s.key&&e.unexpected(),s.computed=!1,s.key=e.startNodeAt(r,n),s.key.name=t,e.finishNode(s.key,"Identifier"),!1))};s.kind="method",s.static=i("static");var r=this.eat(V.star),n=!1;r||(this.options.ecmaVersion>=8&&i("async",!0)?n=!0:i("get")?s.kind="get":i("set")&&(s.kind="set")),s.key||this.parsePropertyName(s);var a=s.key;return s.computed||s.static||!("Identifier"===a.type&&"constructor"===a.name||"Literal"===a.type&&"constructor"===a.value)?s.static&&"Identifier"===a.type&&"prototype"===a.name&&this.raise(a.start,"Classes may not have a static property named prototype"):("method"!==s.kind&&this.raise(a.start,"Constructor can't have get/set modifier"),r&&this.raise(a.start,"Constructor can't be a generator"),n&&this.raise(a.start,"Constructor can't be an async method"),s.kind="constructor"),this.parseClassMethod(t,s,r,n),"get"===s.kind&&0!==s.value.params.length&&this.raiseRecoverable(s.value.start,"getter should have no params"),"set"===s.kind&&1!==s.value.params.length&&this.raiseRecoverable(s.value.start,"setter should have exactly one param"),"set"===s.kind&&"RestElement"===s.value.params[0].type&&this.raiseRecoverable(s.value.params[0].start,"Setter cannot use rest params"),s},X.parseClassMethod=function(t,e,s,i){e.value=this.parseMethod(s,i),t.body.push(this.finishNode(e,"MethodDefinition"))},X.parseClassId=function(t,e){t.id=this.type===V.name?this.parseIdent():!0===e?this.unexpected():null},X.parseClassSuper=function(t){t.superClass=this.eat(V._extends)?this.parseExprSubscripts():null},X.parseExport=function(t,e){var s=this;if(this.next(),this.eat(V.star))return this.expectContextual("from"),this.type!==V.string&&this.unexpected(),t.source=this.parseExprAtom(),this.semicolon(),this.finishNode(t,"ExportAllDeclaration");if(this.eat(V._default)){this.checkExport(e,"default",this.lastTokStart);var i;if(this.type===V._function||(i=this.isAsyncFunction())){var r=this.startNode();this.next(),i&&this.next(),t.declaration=this.parseFunction(r,"nullableID",!1,i)}else if(this.type===V._class){var n=this.startNode();t.declaration=this.parseClass(n,"nullableID")}else t.declaration=this.parseMaybeAssign(),this.semicolon();return this.finishNode(t,"ExportDefaultDeclaration")}if(this.shouldParseExportStatement())t.declaration=this.parseStatement(!0),"VariableDeclaration"===t.declaration.type?this.checkVariableExport(e,t.declaration.declarations):this.checkExport(e,t.declaration.id.name,t.declaration.id.start),t.specifiers=[],t.source=null;else{if(t.declaration=null,t.specifiers=this.parseExportSpecifiers(e),this.eatContextual("from"))this.type!==V.string&&this.unexpected(),t.source=this.parseExprAtom();else{for(var a=0,o=t.specifiers;a<o.length;a+=1){var h=o[a];s.checkUnreserved(h.local)}t.source=null}this.semicolon()}return this.finishNode(t,"ExportNamedDeclaration")},X.checkExport=function(t,e,s){t&&(o(t,e)&&this.raiseRecoverable(s,"Duplicate export '"+e+"'"),t[e]=!0)},X.checkPatternExport=function(t,e){var s=this,i=e.type;if("Identifier"==i)this.checkExport(t,e.name,e.start);else if("ObjectPattern"==i)for(var r=0,n=e.properties;r<n.length;r+=1){var a=n[r];s.checkPatternExport(t,a.value)}else if("ArrayPattern"==i)for(var o=0,h=e.elements;o<h.length;o+=1){var p=h[o];p&&s.checkPatternExport(t,p)}else"AssignmentPattern"==i?this.checkPatternExport(t,e.left):"ParenthesizedExpression"==i&&this.checkPatternExport(t,e.expression)},X.checkVariableExport=function(t,e){var s=this;if(t)for(var i=0,r=e;i<r.length;i+=1){var n=r[i];s.checkPatternExport(t,n.id)}},X.shouldParseExportStatement=function(){return"var"===this.type.keyword||"const"===this.type.keyword||"class"===this.type.keyword||"function"===this.type.keyword||this.isLet()||this.isAsyncFunction()},X.parseExportSpecifiers=function(t){var e=this,s=[],i=!0;for(this.expect(V.braceL);!this.eat(V.braceR);){if(i)i=!1;else if(e.expect(V.comma),e.afterTrailingComma(V.braceR))break;var r=e.startNode();r.local=e.parseIdent(!0),r.exported=e.eatContextual("as")?e.parseIdent(!0):r.local,e.checkExport(t,r.exported.name,r.exported.start),s.push(e.finishNode(r,"ExportSpecifier"))}return s},X.parseImport=function(t){return this.next(),this.type===V.string?(t.specifiers=Z,t.source=this.parseExprAtom()):(t.specifiers=this.parseImportSpecifiers(),this.expectContextual("from"),t.source=this.type===V.string?this.parseExprAtom():this.unexpected()),this.semicolon(),this.finishNode(t,"ImportDeclaration")},X.parseImportSpecifiers=function(){var t=this,e=[],s=!0;if(this.type===V.name){var i=this.startNode();if(i.local=this.parseIdent(),this.checkLVal(i.local,"let"),e.push(this.finishNode(i,"ImportDefaultSpecifier")),!this.eat(V.comma))return e}if(this.type===V.star){var r=this.startNode();return this.next(),this.expectContextual("as"),r.local=this.parseIdent(),this.checkLVal(r.local,"let"),e.push(this.finishNode(r,"ImportNamespaceSpecifier")),e}for(this.expect(V.braceL);!this.eat(V.braceR);){if(s)s=!1;else if(t.expect(V.comma),t.afterTrailingComma(V.braceR))break;var n=t.startNode();n.imported=t.parseIdent(!0),t.eatContextual("as")?n.local=t.parseIdent():(t.checkUnreserved(n.imported),n.local=n.imported),t.checkLVal(n.local,"let"),e.push(t.finishNode(n,"ImportSpecifier"))}return e},X.adaptDirectivePrologue=function(t){for(var e=0;e<t.length&&this.isDirectiveCandidate(t[e]);++e)t[e].directive=t[e].expression.raw.slice(1,-1)},X.isDirectiveCandidate=function(t){return"ExpressionStatement"===t.type&&"Literal"===t.expression.type&&"string"==typeof t.expression.value&&('"'===this.input[t.start]||"'"===this.input[t.start])};var tt=$.prototype;tt.toAssignable=function(t,e,s){var i=this;if(this.options.ecmaVersion>=6&&t)switch(t.type){case"Identifier":this.inAsync&&"await"===t.name&&this.raise(t.start,"Can not use 'await' as identifier inside an async function");break;case"ObjectPattern":case"ArrayPattern":case"RestElement":break;case"ObjectExpression":t.type="ObjectPattern",s&&this.checkPatternErrors(s,!0);for(var r=0,n=t.properties;r<n.length;r+=1){var a=n[r];i.toAssignable(a,e)}break;case"Property":"init"!==t.kind&&this.raise(t.key.start,"Object pattern can't contain getter or setter"),this.toAssignable(t.value,e);break;case"ArrayExpression":t.type="ArrayPattern",s&&this.checkPatternErrors(s,!0),this.toAssignableList(t.elements,e);break;case"SpreadElement":t.type="RestElement",this.toAssignable(t.argument,e),"AssignmentPattern"===t.argument.type&&this.raise(t.argument.start,"Rest elements cannot have a default value");break;case"AssignmentExpression":"="!==t.operator&&this.raise(t.left.end,"Only '=' operator can be used for specifying default value."),t.type="AssignmentPattern",delete t.operator,this.toAssignable(t.left,e);case"AssignmentPattern":break;case"ParenthesizedExpression":this.toAssignable(t.expression,e);break;case"MemberExpression":if(!e)break;default:this.raise(t.start,"Assigning to rvalue")}else s&&this.checkPatternErrors(s,!0);return t},tt.toAssignableList=function(t,e){for(var s=this,i=t.length,r=0;r<i;r++){var n=t[r];n&&s.toAssignable(n,e)}if(i){var a=t[i-1];6===this.options.ecmaVersion&&e&&a&&"RestElement"===a.type&&"Identifier"!==a.argument.type&&this.unexpected(a.argument.start)}return t},tt.parseSpread=function(t){var e=this.startNode();return this.next(),e.argument=this.parseMaybeAssign(!1,t),this.finishNode(e,"SpreadElement")},tt.parseRestBinding=function(){var t=this.startNode();return this.next(),6===this.options.ecmaVersion&&this.type!==V.name&&this.unexpected(),t.argument=this.parseBindingAtom(),this.finishNode(t,"RestElement")},tt.parseBindingAtom=function(){if(this.options.ecmaVersion>=6)switch(this.type){case V.bracketL:var t=this.startNode();return this.next(),t.elements=this.parseBindingList(V.bracketR,!0,!0),this.finishNode(t,"ArrayPattern");case V.braceL:return this.parseObj(!0)}return this.parseIdent()},tt.parseBindingList=function(t,e,s){
+for(var i=this,r=[],n=!0;!this.eat(t);)if(n?n=!1:i.expect(V.comma),e&&i.type===V.comma)r.push(null);else{if(s&&i.afterTrailingComma(t))break;if(i.type===V.ellipsis){var a=i.parseRestBinding();i.parseBindingListItem(a),r.push(a),i.type===V.comma&&i.raise(i.start,"Comma is not permitted after the rest element"),i.expect(t);break}var o=i.parseMaybeDefault(i.start,i.startLoc);i.parseBindingListItem(o),r.push(o)}return r},tt.parseBindingListItem=function(t){return t},tt.parseMaybeDefault=function(t,e,s){if(s=s||this.parseBindingAtom(),this.options.ecmaVersion<6||!this.eat(V.eq))return s;var i=this.startNodeAt(t,e);return i.left=s,i.right=this.parseMaybeAssign(),this.finishNode(i,"AssignmentPattern")},tt.checkLVal=function(t,e,s){var i=this;switch(t.type){case"Identifier":this.strict&&this.reservedWordsStrictBind.test(t.name)&&this.raiseRecoverable(t.start,(e?"Binding ":"Assigning to ")+t.name+" in strict mode"),s&&(o(s,t.name)&&this.raiseRecoverable(t.start,"Argument name clash"),s[t.name]=!0),e&&"none"!==e&&(("var"===e&&!this.canDeclareVarName(t.name)||"var"!==e&&!this.canDeclareLexicalName(t.name))&&this.raiseRecoverable(t.start,"Identifier '"+t.name+"' has already been declared"),"var"===e?this.declareVarName(t.name):this.declareLexicalName(t.name));break;case"MemberExpression":e&&this.raiseRecoverable(t.start,"Binding member expression");break;case"ObjectPattern":for(var r=0,n=t.properties;r<n.length;r+=1){var a=n[r];i.checkLVal(a,e,s)}break;case"Property":this.checkLVal(t.value,e,s);break;case"ArrayPattern":for(var h=0,p=t.elements;h<p.length;h+=1){var c=p[h];c&&i.checkLVal(c,e,s)}break;case"AssignmentPattern":this.checkLVal(t.left,e,s);break;case"RestElement":this.checkLVal(t.argument,e,s);break;case"ParenthesizedExpression":this.checkLVal(t.expression,e,s);break;default:this.raise(t.start,(e?"Binding":"Assigning to")+" rvalue")}};var et=$.prototype;et.checkPropClash=function(t,e,s){if(!(this.options.ecmaVersion>=6&&(t.computed||t.method||t.shorthand))){var i,r=t.key;switch(r.type){case"Identifier":i=r.name;break;case"Literal":i=String(r.value);break;default:return}var n=t.kind;if(this.options.ecmaVersion>=6)return void("__proto__"===i&&"init"===n&&(e.proto&&(s&&s.doubleProto<0?s.doubleProto=r.start:this.raiseRecoverable(r.start,"Redefinition of __proto__ property")),e.proto=!0));i="$"+i;var a=e[i];if(a){var o;o="init"===n?this.strict&&a.init||a.get||a.set:a.init||a[n],o&&this.raiseRecoverable(r.start,"Redefinition of property")}else a=e[i]={init:!1,get:!1,set:!1};a[n]=!0}},et.parseExpression=function(t,e){var s=this,i=this.start,r=this.startLoc,n=this.parseMaybeAssign(t,e);if(this.type===V.comma){var a=this.startNodeAt(i,r);for(a.expressions=[n];this.eat(V.comma);)a.expressions.push(s.parseMaybeAssign(t,e));return this.finishNode(a,"SequenceExpression")}return n},et.parseMaybeAssign=function(t,e,s){if(this.inGenerator&&this.isContextual("yield"))return this.parseYield();var i=!1,r=-1,n=-1;e?(r=e.parenthesizedAssign,n=e.trailingComma,e.parenthesizedAssign=e.trailingComma=-1):(e=new u,i=!0);var a=this.start,o=this.startLoc;this.type!=V.parenL&&this.type!=V.name||(this.potentialArrowAt=this.start);var h=this.parseMaybeConditional(t,e);if(s&&(h=s.call(this,h,a,o)),this.type.isAssign){var p=this.startNodeAt(a,o);return p.operator=this.value,p.left=this.type===V.eq?this.toAssignable(h,!1,e):h,i||u.call(e),e.shorthandAssign=-1,this.checkLVal(h),this.next(),p.right=this.parseMaybeAssign(t),this.finishNode(p,"AssignmentExpression")}return i&&this.checkExpressionErrors(e,!0),r>-1&&(e.parenthesizedAssign=r),n>-1&&(e.trailingComma=n),h},et.parseMaybeConditional=function(t,e){var s=this.start,i=this.startLoc,r=this.parseExprOps(t,e);if(this.checkExpressionErrors(e))return r;if(this.eat(V.question)){var n=this.startNodeAt(s,i);return n.test=r,n.consequent=this.parseMaybeAssign(),this.expect(V.colon),n.alternate=this.parseMaybeAssign(t),this.finishNode(n,"ConditionalExpression")}return r},et.parseExprOps=function(t,e){var s=this.start,i=this.startLoc,r=this.parseMaybeUnary(e,!1);return this.checkExpressionErrors(e)?r:r.start==s&&"ArrowFunctionExpression"===r.type?r:this.parseExprOp(r,s,i,-1,t)},et.parseExprOp=function(t,e,s,i,r){var n=this.type.binop;if(null!=n&&(!r||this.type!==V._in)&&n>i){var a=this.type===V.logicalOR||this.type===V.logicalAND,o=this.value;this.next();var h=this.start,p=this.startLoc,c=this.parseExprOp(this.parseMaybeUnary(null,!1),h,p,n,r),l=this.buildBinary(e,s,t,c,o,a);return this.parseExprOp(l,e,s,i,r)}return t},et.buildBinary=function(t,e,s,i,r,n){var a=this.startNodeAt(t,e);return a.left=s,a.operator=r,a.right=i,this.finishNode(a,n?"LogicalExpression":"BinaryExpression")},et.parseMaybeUnary=function(t,e){var s,i=this,r=this.start,n=this.startLoc;if(this.inAsync&&this.isContextual("await"))s=this.parseAwait(),e=!0;else if(this.type.prefix){var a=this.startNode(),o=this.type===V.incDec;a.operator=this.value,a.prefix=!0,this.next(),a.argument=this.parseMaybeUnary(null,!0),this.checkExpressionErrors(t,!0),o?this.checkLVal(a.argument):this.strict&&"delete"===a.operator&&"Identifier"===a.argument.type?this.raiseRecoverable(a.start,"Deleting local variable in strict mode"):e=!0,s=this.finishNode(a,o?"UpdateExpression":"UnaryExpression")}else{if(s=this.parseExprSubscripts(t),this.checkExpressionErrors(t))return s;for(;this.type.postfix&&!this.canInsertSemicolon();){var h=i.startNodeAt(r,n);h.operator=i.value,h.prefix=!1,h.argument=s,i.checkLVal(s),i.next(),s=i.finishNode(h,"UpdateExpression")}}return!e&&this.eat(V.starstar)?this.buildBinary(r,n,s,this.parseMaybeUnary(null,!1),"**",!1):s},et.parseExprSubscripts=function(t){var e=this.start,s=this.startLoc,i=this.parseExprAtom(t),r="ArrowFunctionExpression"===i.type&&")"!==this.input.slice(this.lastTokStart,this.lastTokEnd);if(this.checkExpressionErrors(t)||r)return i;var n=this.parseSubscripts(i,e,s);return t&&"MemberExpression"===n.type&&(t.parenthesizedAssign>=n.start&&(t.parenthesizedAssign=-1),t.parenthesizedBind>=n.start&&(t.parenthesizedBind=-1)),n},et.parseSubscripts=function(t,e,s,i){for(var r=this,n=this.options.ecmaVersion>=8&&"Identifier"===t.type&&"async"===t.name&&this.lastTokEnd==t.end&&!this.canInsertSemicolon()&&"async"===this.input.slice(t.start,t.end),a=void 0;;)if((a=r.eat(V.bracketL))||r.eat(V.dot)){var o=r.startNodeAt(e,s);o.object=t,o.property=a?r.parseExpression():r.parseIdent(!0),o.computed=!!a,a&&r.expect(V.bracketR),t=r.finishNode(o,"MemberExpression")}else if(!i&&r.eat(V.parenL)){var h=new u,p=r.yieldPos,c=r.awaitPos;r.yieldPos=0,r.awaitPos=0;var l=r.parseExprList(V.parenR,r.options.ecmaVersion>=8,!1,h);if(n&&!r.canInsertSemicolon()&&r.eat(V.arrow))return r.checkPatternErrors(h,!1),r.checkYieldAwaitInDefaultParams(),r.yieldPos=p,r.awaitPos=c,r.parseArrowExpression(r.startNodeAt(e,s),l,!0);r.checkExpressionErrors(h,!0),r.yieldPos=p||r.yieldPos,r.awaitPos=c||r.awaitPos;var d=r.startNodeAt(e,s);d.callee=t,d.arguments=l,t=r.finishNode(d,"CallExpression")}else{if(r.type!==V.backQuote)return t;var f=r.startNodeAt(e,s);f.tag=t,f.quasi=r.parseTemplate({isTagged:!0}),t=r.finishNode(f,"TaggedTemplateExpression")}},et.parseExprAtom=function(t){var e,s=this.potentialArrowAt==this.start;switch(this.type){case V._super:return this.inFunction||this.raise(this.start,"'super' outside of function or class"),e=this.startNode(),this.next(),this.type!==V.dot&&this.type!==V.bracketL&&this.type!==V.parenL&&this.unexpected(),this.finishNode(e,"Super");case V._this:return e=this.startNode(),this.next(),this.finishNode(e,"ThisExpression");case V.name:var i=this.start,r=this.startLoc,n=this.containsEsc,a=this.parseIdent(this.type!==V.name);if(this.options.ecmaVersion>=8&&!n&&"async"===a.name&&!this.canInsertSemicolon()&&this.eat(V._function))return this.parseFunction(this.startNodeAt(i,r),!1,!1,!0);if(s&&!this.canInsertSemicolon()){if(this.eat(V.arrow))return this.parseArrowExpression(this.startNodeAt(i,r),[a],!1);if(this.options.ecmaVersion>=8&&"async"===a.name&&this.type===V.name&&!n)return a=this.parseIdent(),!this.canInsertSemicolon()&&this.eat(V.arrow)||this.unexpected(),this.parseArrowExpression(this.startNodeAt(i,r),[a],!0)}return a;case V.regexp:var o=this.value;return e=this.parseLiteral(o.value),e.regex={pattern:o.pattern,flags:o.flags},e;case V.num:case V.string:return this.parseLiteral(this.value);case V._null:case V._true:case V._false:return e=this.startNode(),e.value=this.type===V._null?null:this.type===V._true,e.raw=this.type.keyword,this.next(),this.finishNode(e,"Literal");case V.parenL:var h=this.start,p=this.parseParenAndDistinguishExpression(s);return t&&(t.parenthesizedAssign<0&&!this.isSimpleAssignTarget(p)&&(t.parenthesizedAssign=h),t.parenthesizedBind<0&&(t.parenthesizedBind=h)),p;case V.bracketL:return e=this.startNode(),this.next(),e.elements=this.parseExprList(V.bracketR,!0,!0,t),this.finishNode(e,"ArrayExpression");case V.braceL:return this.parseObj(!1,t);case V._function:return e=this.startNode(),this.next(),this.parseFunction(e,!1);case V._class:return this.parseClass(this.startNode(),!1);case V._new:return this.parseNew();case V.backQuote:return this.parseTemplate();default:this.unexpected()}},et.parseLiteral=function(t){var e=this.startNode();return e.value=t,e.raw=this.input.slice(this.start,this.end),this.next(),this.finishNode(e,"Literal")},et.parseParenExpression=function(){this.expect(V.parenL);var t=this.parseExpression();return this.expect(V.parenR),t},et.parseParenAndDistinguishExpression=function(t){var e,s=this,i=this.start,r=this.startLoc,n=this.options.ecmaVersion>=8;if(this.options.ecmaVersion>=6){this.next();var a,o=this.start,h=this.startLoc,p=[],c=!0,l=!1,d=new u,f=this.yieldPos,m=this.awaitPos;for(this.yieldPos=0,this.awaitPos=0;this.type!==V.parenR;){if(c?c=!1:s.expect(V.comma),n&&s.afterTrailingComma(V.parenR,!0)){l=!0;break}if(s.type===V.ellipsis){a=s.start,p.push(s.parseParenItem(s.parseRestBinding())),s.type===V.comma&&s.raise(s.start,"Comma is not permitted after the rest element");break}p.push(s.parseMaybeAssign(!1,d,s.parseParenItem))}var x=this.start,y=this.startLoc;if(this.expect(V.parenR),t&&!this.canInsertSemicolon()&&this.eat(V.arrow))return this.checkPatternErrors(d,!1),this.checkYieldAwaitInDefaultParams(),this.yieldPos=f,this.awaitPos=m,this.parseParenArrowList(i,r,p);p.length&&!l||this.unexpected(this.lastTokStart),a&&this.unexpected(a),this.checkExpressionErrors(d,!0),this.yieldPos=f||this.yieldPos,this.awaitPos=m||this.awaitPos,p.length>1?(e=this.startNodeAt(o,h),e.expressions=p,this.finishNodeAt(e,"SequenceExpression",x,y)):e=p[0]}else e=this.parseParenExpression();if(this.options.preserveParens){var v=this.startNodeAt(i,r);return v.expression=e,this.finishNode(v,"ParenthesizedExpression")}return e},et.parseParenItem=function(t){return t},et.parseParenArrowList=function(t,e,s){return this.parseArrowExpression(this.startNodeAt(t,e),s)};var st=[];et.parseNew=function(){var t=this.startNode(),e=this.parseIdent(!0);if(this.options.ecmaVersion>=6&&this.eat(V.dot)){t.meta=e;var s=this.containsEsc;return t.property=this.parseIdent(!0),("target"!==t.property.name||s)&&this.raiseRecoverable(t.property.start,"The only valid meta property for new is new.target"),this.inFunction||this.raiseRecoverable(t.start,"new.target can only be used in functions"),this.finishNode(t,"MetaProperty")}var i=this.start,r=this.startLoc;return t.callee=this.parseSubscripts(this.parseExprAtom(),i,r,!0),this.eat(V.parenL)?t.arguments=this.parseExprList(V.parenR,this.options.ecmaVersion>=8,!1):t.arguments=st,this.finishNode(t,"NewExpression")},et.parseTemplateElement=function(t){var e=t.isTagged,s=this.startNode();return this.type===V.invalidTemplate?(e||this.raiseRecoverable(this.start,"Bad escape sequence in untagged template literal"),s.value={raw:this.value,cooked:null}):s.value={raw:this.input.slice(this.start,this.end).replace(/\r\n?/g,"\n"),cooked:this.value},this.next(),s.tail=this.type===V.backQuote,this.finishNode(s,"TemplateElement")},et.parseTemplate=function(t){var e=this;void 0===t&&(t={});var s=t.isTagged;void 0===s&&(s=!1);var i=this.startNode();this.next(),i.expressions=[];var r=this.parseTemplateElement({isTagged:s});for(i.quasis=[r];!r.tail;)e.expect(V.dollarBraceL),i.expressions.push(e.parseExpression()),e.expect(V.braceR),i.quasis.push(r=e.parseTemplateElement({isTagged:s}));return this.next(),this.finishNode(i,"TemplateLiteral")},et.isAsyncProp=function(t){return!t.computed&&"Identifier"===t.key.type&&"async"===t.key.name&&(this.type===V.name||this.type===V.num||this.type===V.string||this.type===V.bracketL||this.type.keyword)&&!F.test(this.input.slice(this.lastTokEnd,this.start))},et.parseObj=function(t,e){var s=this,i=this.startNode(),r=!0,n={};for(i.properties=[],this.next();!this.eat(V.braceR);){if(r)r=!1;else if(s.expect(V.comma),s.afterTrailingComma(V.braceR))break;var a=s.parseProperty(t,e);t||s.checkPropClash(a,n,e),i.properties.push(a)}return this.finishNode(i,t?"ObjectPattern":"ObjectExpression")},et.parseProperty=function(t,e){var s,i,r,n,a=this.startNode();this.options.ecmaVersion>=6&&(a.method=!1,a.shorthand=!1,(t||e)&&(r=this.start,n=this.startLoc),t||(s=this.eat(V.star)));var o=this.containsEsc;return this.parsePropertyName(a),!t&&!o&&this.options.ecmaVersion>=8&&!s&&this.isAsyncProp(a)?(i=!0,this.parsePropertyName(a,e)):i=!1,this.parsePropertyValue(a,t,s,i,r,n,e,o),this.finishNode(a,"Property")},et.parsePropertyValue=function(t,e,s,i,r,n,a,o){if((s||i)&&this.type===V.colon&&this.unexpected(),this.eat(V.colon))t.value=e?this.parseMaybeDefault(this.start,this.startLoc):this.parseMaybeAssign(!1,a),t.kind="init";else if(this.options.ecmaVersion>=6&&this.type===V.parenL)e&&this.unexpected(),t.kind="init",t.method=!0,t.value=this.parseMethod(s,i);else if(e||o||!(this.options.ecmaVersion>=5)||t.computed||"Identifier"!==t.key.type||"get"!==t.key.name&&"set"!==t.key.name||this.type==V.comma||this.type==V.braceR)this.options.ecmaVersion>=6&&!t.computed&&"Identifier"===t.key.type?(this.checkUnreserved(t.key),t.kind="init",e?t.value=this.parseMaybeDefault(r,n,t.key):this.type===V.eq&&a?(a.shorthandAssign<0&&(a.shorthandAssign=this.start),t.value=this.parseMaybeDefault(r,n,t.key)):t.value=t.key,t.shorthand=!0):this.unexpected();else{(s||i)&&this.unexpected(),t.kind=t.key.name,this.parsePropertyName(t),t.value=this.parseMethod(!1);var h="get"===t.kind?0:1;if(t.value.params.length!==h){var p=t.value.start;"get"===t.kind?this.raiseRecoverable(p,"getter should have no params"):this.raiseRecoverable(p,"setter should have exactly one param")}else"set"===t.kind&&"RestElement"===t.value.params[0].type&&this.raiseRecoverable(t.value.params[0].start,"Setter cannot use rest params")}},et.parsePropertyName=function(t){if(this.options.ecmaVersion>=6){if(this.eat(V.bracketL))return t.computed=!0,t.key=this.parseMaybeAssign(),this.expect(V.bracketR),t.key;t.computed=!1}return t.key=this.type===V.num||this.type===V.string?this.parseExprAtom():this.parseIdent(!0)},et.initFunction=function(t){t.id=null,this.options.ecmaVersion>=6&&(t.generator=!1,t.expression=!1),this.options.ecmaVersion>=8&&(t.async=!1)},et.parseMethod=function(t,e){var s=this.startNode(),i=this.inGenerator,r=this.inAsync,n=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.initFunction(s),this.options.ecmaVersion>=6&&(s.generator=t),this.options.ecmaVersion>=8&&(s.async=!!e),this.inGenerator=s.generator,this.inAsync=s.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,this.enterFunctionScope(),this.expect(V.parenL),s.params=this.parseBindingList(V.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams(),this.parseFunctionBody(s,!1),this.inGenerator=i,this.inAsync=r,this.yieldPos=n,this.awaitPos=a,this.inFunction=o,this.finishNode(s,"FunctionExpression")},et.parseArrowExpression=function(t,e,s){var i=this.inGenerator,r=this.inAsync,n=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.enterFunctionScope(),this.initFunction(t),this.options.ecmaVersion>=8&&(t.async=!!s),this.inGenerator=!1,this.inAsync=t.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,t.params=this.toAssignableList(e,!0),this.parseFunctionBody(t,!0),this.inGenerator=i,this.inAsync=r,this.yieldPos=n,this.awaitPos=a,this.inFunction=o,this.finishNode(t,"ArrowFunctionExpression")},et.parseFunctionBody=function(t,e){var s=e&&this.type!==V.braceL,i=this.strict,r=!1;if(s)t.body=this.parseMaybeAssign(),t.expression=!0,this.checkParams(t,!1);else{var n=this.options.ecmaVersion>=7&&!this.isSimpleParamList(t.params);i&&!n||(r=this.strictDirective(this.end))&&n&&this.raiseRecoverable(t.start,"Illegal 'use strict' directive in function with non-simple parameter list");var a=this.labels;this.labels=[],r&&(this.strict=!0),this.checkParams(t,!i&&!r&&!e&&this.isSimpleParamList(t.params)),t.body=this.parseBlock(!1),t.expression=!1,this.adaptDirectivePrologue(t.body.body),this.labels=a}this.exitFunctionScope(),this.strict&&t.id&&this.checkLVal(t.id,"none"),this.strict=i},et.isSimpleParamList=function(t){for(var e=0,s=t;e<s.length;e+=1){if("Identifier"!==s[e].type)return!1}return!0},et.checkParams=function(t,e){for(var s=this,i={},r=0,n=t.params;r<n.length;r+=1){var a=n[r];s.checkLVal(a,"var",e?null:i)}},et.parseExprList=function(t,e,s,i){for(var r=this,n=[],a=!0;!this.eat(t);){if(a)a=!1;else if(r.expect(V.comma),e&&r.afterTrailingComma(t))break;var o=void 0;s&&r.type===V.comma?o=null:r.type===V.ellipsis?(o=r.parseSpread(i),i&&r.type===V.comma&&i.trailingComma<0&&(i.trailingComma=r.start)):o=r.parseMaybeAssign(!1,i),n.push(o)}return n},et.checkUnreserved=function(t){var e=t.start,s=t.end,i=t.name;if(this.inGenerator&&"yield"===i&&this.raiseRecoverable(e,"Can not use 'yield' as identifier inside a generator"),this.inAsync&&"await"===i&&this.raiseRecoverable(e,"Can not use 'await' as identifier inside an async function"),this.isKeyword(i)&&this.raise(e,"Unexpected keyword '"+i+"'"),!(this.options.ecmaVersion<6&&-1!=this.input.slice(e,s).indexOf("\\"))){(this.strict?this.reservedWordsStrict:this.reservedWords).test(i)&&(this.inAsync||"await"!==i||this.raiseRecoverable(e,"Can not use keyword 'await' outside an async function"),this.raiseRecoverable(e,"The keyword '"+i+"' is reserved"))}},et.parseIdent=function(t,e){var s=this.startNode();return t&&"never"==this.options.allowReserved&&(t=!1),this.type===V.name?s.name=this.value:this.type.keyword?(s.name=this.type.keyword,"class"!==s.name&&"function"!==s.name||this.lastTokEnd===this.lastTokStart+1&&46===this.input.charCodeAt(this.lastTokStart)||this.context.pop()):this.unexpected(),this.next(),this.finishNode(s,"Identifier"),t||this.checkUnreserved(s),s},et.parseYield=function(){this.yieldPos||(this.yieldPos=this.start);var t=this.startNode();return this.next(),this.type==V.semi||this.canInsertSemicolon()||this.type!=V.star&&!this.type.startsExpr?(t.delegate=!1,t.argument=null):(t.delegate=this.eat(V.star),t.argument=this.parseMaybeAssign()),this.finishNode(t,"YieldExpression")},et.parseAwait=function(){this.awaitPos||(this.awaitPos=this.start);var t=this.startNode();return this.next(),t.argument=this.parseMaybeUnary(null,!0),this.finishNode(t,"AwaitExpression")};var it=$.prototype;it.raise=function(t,e){var s=h(this.input,t);e+=" ("+s.line+":"+s.column+")";var i=new SyntaxError(e);throw i.pos=t,i.loc=s,i.raisedAt=this.pos,i},it.raiseRecoverable=it.raise,it.curPosition=function(){if(this.options.locations)return new j(this.curLine,this.pos-this.lineStart)};var rt=$.prototype,nt=Object.assign||function(t){for(var e=[],s=arguments.length-1;s-- >0;)e[s]=arguments[s+1];for(var i=0,r=e;i<r.length;i+=1){var n=r[i];for(var a in n)o(n,a)&&(t[a]=n[a])}return t};rt.enterFunctionScope=function(){this.scopeStack.push({var:{},lexical:{},childVar:{},parentLexical:{}})},rt.exitFunctionScope=function(){this.scopeStack.pop()},rt.enterLexicalScope=function(){var t=this.scopeStack[this.scopeStack.length-1],e={var:{},lexical:{},childVar:{},parentLexical:{}};this.scopeStack.push(e),nt(e.parentLexical,t.lexical,t.parentLexical)},rt.exitLexicalScope=function(){var t=this.scopeStack.pop(),e=this.scopeStack[this.scopeStack.length-1];nt(e.childVar,t.var,t.childVar)},rt.canDeclareVarName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e.parentLexical,t)},rt.canDeclareLexicalName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e.var,t)&&!o(e.childVar,t)},rt.declareVarName=function(t){this.scopeStack[this.scopeStack.length-1].var[t]=!0},rt.declareLexicalName=function(t){this.scopeStack[this.scopeStack.length-1].lexical[t]=!0};var at=function(t,e,s){this.type="",this.start=e,this.end=0,t.options.locations&&(this.loc=new W(t,s)),t.options.directSourceFile&&(this.sourceFile=t.options.directSourceFile),t.options.ranges&&(this.range=[e,0])},ot=$.prototype;ot.startNode=function(){return new at(this,this.start,this.startLoc)},ot.startNodeAt=function(t,e){return new at(this,t,e)},ot.finishNode=function(t,e){return d.call(this,t,e,this.lastTokEnd,this.lastTokEndLoc)},ot.finishNodeAt=function(t,e,s,i){return d.call(this,t,e,s,i)};var ht=function(t,e,s,i,r){this.token=t,this.isExpr=!!e,this.preserveSpace=!!s,this.override=i,this.generator=!!r},pt={b_stat:new ht("{",!1),b_expr:new ht("{",!0),b_tmpl:new ht("${",!1),p_stat:new ht("(",!1),p_expr:new ht("(",!0),q_tmpl:new ht("`",!0,!0,function(t){return t.tryReadTemplateToken()}),f_stat:new ht("function",!1),f_expr:new ht("function",!0),f_expr_gen:new ht("function",!0,!1,null,!0),f_gen:new ht("function",!1,!1,null,!0)},ct=$.prototype;ct.initialContext=function(){return[pt.b_stat]},ct.braceIsBlock=function(t){var e=this.curContext();return e===pt.f_expr||e===pt.f_stat||(t!==V.colon||e!==pt.b_stat&&e!==pt.b_expr?t===V._return||t==V.name&&this.exprAllowed?F.test(this.input.slice(this.lastTokEnd,this.start)):t===V._else||t===V.semi||t===V.eof||t===V.parenR||t==V.arrow||(t==V.braceL?e===pt.b_stat:t!=V._var&&t!=V.name&&!this.exprAllowed):!e.isExpr)},ct.inGeneratorContext=function(){for(var t=this,e=this.context.length-1;e>=1;e--){var s=t.context[e];if("function"===s.token)return s.generator}return!1},ct.updateContext=function(t){var e,s=this.type;s.keyword&&t==V.dot?this.exprAllowed=!1:(e=s.updateContext)?e.call(this,t):this.exprAllowed=s.beforeExpr},V.parenR.updateContext=V.braceR.updateContext=function(){if(1==this.context.length)return void(this.exprAllowed=!0);var t=this.context.pop();t===pt.b_stat&&"function"===this.curContext().token&&(t=this.context.pop()),this.exprAllowed=!t.isExpr},V.braceL.updateContext=function(t){this.context.push(this.braceIsBlock(t)?pt.b_stat:pt.b_expr),this.exprAllowed=!0},V.dollarBraceL.updateContext=function(){this.context.push(pt.b_tmpl),this.exprAllowed=!0},V.parenL.updateContext=function(t){var e=t===V._if||t===V._for||t===V._with||t===V._while;this.context.push(e?pt.p_stat:pt.p_expr),this.exprAllowed=!0},V.incDec.updateContext=function(){},V._function.updateContext=V._class.updateContext=function(t){t.beforeExpr&&t!==V.semi&&t!==V._else&&(t!==V.colon&&t!==V.braceL||this.curContext()!==pt.b_stat)?this.context.push(pt.f_expr):this.context.push(pt.f_stat),this.exprAllowed=!1},V.backQuote.updateContext=function(){this.curContext()===pt.q_tmpl?this.context.pop():this.context.push(pt.q_tmpl),this.exprAllowed=!1},V.star.updateContext=function(t){if(t==V._function){var e=this.context.length-1;this.context[e]===pt.f_expr?this.context[e]=pt.f_expr_gen:this.context[e]=pt.f_gen}this.exprAllowed=!0},V.name.updateContext=function(t){var e=!1;this.options.ecmaVersion>=6&&("of"==this.value&&!this.exprAllowed||"yield"==this.value&&this.inGeneratorContext())&&(e=!0),this.exprAllowed=e};var lt=function(t){this.type=t.type,this.value=t.value,this.start=t.start,this.end=t.end,t.options.locations&&(this.loc=new W(t,t.startLoc,t.endLoc)),t.options.ranges&&(this.range=[t.start,t.end])},ut=$.prototype,dt="object"==typeof Packages&&"[object JavaPackage]"==Object.prototype.toString.call(Packages);ut.next=function(){this.options.onToken&&this.options.onToken(new lt(this)),this.lastTokEnd=this.end,this.lastTokStart=this.start,this.lastTokEndLoc=this.endLoc,this.lastTokStartLoc=this.startLoc,this.nextToken()},ut.getToken=function(){return this.next(),new lt(this)},"undefined"!=typeof Symbol&&(ut[Symbol.iterator]=function(){var t=this;return{next:function(){var e=t.getToken();return{done:e.type===V.eof,value:e}}}}),ut.curContext=function(){return this.context[this.context.length-1]},ut.nextToken=function(){var t=this.curContext();return t&&t.preserveSpace||this.skipSpace(),this.start=this.pos,this.options.locations&&(this.startLoc=this.curPosition()),this.pos>=this.input.length?this.finishToken(V.eof):t.override?t.override(this):void this.readToken(this.fullCharCodeAtPos())},ut.readToken=function(t){return s(t,this.options.ecmaVersion>=6)||92===t?this.readWord():this.getTokenFromCode(t)},ut.fullCharCodeAtPos=function(){var t=this.input.charCodeAt(this.pos);return t<=55295||t>=57344?t:(t<<10)+this.input.charCodeAt(this.pos+1)-56613888},ut.skipBlockComment=function(){var t=this,e=this.options.onComment&&this.curPosition(),s=this.pos,i=this.input.indexOf("*/",this.pos+=2);if(-1===i&&this.raise(this.pos-2,"Unterminated comment"),this.pos=i+2,this.options.locations){D.lastIndex=s;for(var r;(r=D.exec(this.input))&&r.index<this.pos;)++t.curLine,t.lineStart=r.index+r[0].length}this.options.onComment&&this.options.onComment(!0,this.input.slice(s+2,i),s,this.pos,e,this.curPosition())},ut.skipLineComment=function(t){for(var e=this,s=this.pos,i=this.options.onComment&&this.curPosition(),r=this.input.charCodeAt(this.pos+=t);this.pos<this.input.length&&!a(r);)r=e.input.charCodeAt(++e.pos);this.options.onComment&&this.options.onComment(!1,this.input.slice(s+t,this.pos),s,this.pos,i,this.curPosition())},ut.skipSpace=function(){var t=this;t:for(;this.pos<this.input.length;){var e=t.input.charCodeAt(t.pos);switch(e){case 32:case 160:++t.pos;break;case 13:10===t.input.charCodeAt(t.pos+1)&&++t.pos;case 10:case 8232:case 8233:++t.pos,t.options.locations&&(++t.curLine,t.lineStart=t.pos);break;case 47:switch(t.input.charCodeAt(t.pos+1)){case 42:t.skipBlockComment();break;case 47:t.skipLineComment(2);break;default:break t}break;default:if(!(e>8&&e<14||e>=5760&&B.test(String.fromCharCode(e))))break t;++t.pos}}},ut.finishToken=function(t,e){this.end=this.pos,this.options.locations&&(this.endLoc=this.curPosition());var s=this.type;this.type=t,this.value=e,this.updateContext(s)},ut.readToken_dot=function(){var t=this.input.charCodeAt(this.pos+1);if(t>=48&&t<=57)return this.readNumber(!0);var e=this.input.charCodeAt(this.pos+2);return this.options.ecmaVersion>=6&&46===t&&46===e?(this.pos+=3,this.finishToken(V.ellipsis)):(++this.pos,this.finishToken(V.dot))},ut.readToken_slash=function(){var t=this.input.charCodeAt(this.pos+1);return this.exprAllowed?(++this.pos,this.readRegexp()):61===t?this.finishOp(V.assign,2):this.finishOp(V.slash,1)},ut.readToken_mult_modulo_exp=function(t){var e=this.input.charCodeAt(this.pos+1),s=1,i=42===t?V.star:V.modulo;return this.options.ecmaVersion>=7&&42==t&&42===e&&(++s,i=V.starstar,e=this.input.charCodeAt(this.pos+2)),61===e?this.finishOp(V.assign,s+1):this.finishOp(i,s)},ut.readToken_pipe_amp=function(t){var e=this.input.charCodeAt(this.pos+1);return e===t?this.finishOp(124===t?V.logicalOR:V.logicalAND,2):61===e?this.finishOp(V.assign,2):this.finishOp(124===t?V.bitwiseOR:V.bitwiseAND,1)},ut.readToken_caret=function(){return 61===this.input.charCodeAt(this.pos+1)?this.finishOp(V.assign,2):this.finishOp(V.bitwiseXOR,1)},ut.readToken_plus_min=function(t){var e=this.input.charCodeAt(this.pos+1);return e===t?45!=e||this.inModule||62!=this.input.charCodeAt(this.pos+2)||0!==this.lastTokEnd&&!F.test(this.input.slice(this.lastTokEnd,this.pos))?this.finishOp(V.incDec,2):(this.skipLineComment(3),this.skipSpace(),this.nextToken()):61===e?this.finishOp(V.assign,2):this.finishOp(V.plusMin,1)},ut.readToken_lt_gt=function(t){var e=this.input.charCodeAt(this.pos+1),s=1;return e===t?(s=62===t&&62===this.input.charCodeAt(this.pos+2)?3:2,61===this.input.charCodeAt(this.pos+s)?this.finishOp(V.assign,s+1):this.finishOp(V.bitShift,s)):33!=e||60!=t||this.inModule||45!=this.input.charCodeAt(this.pos+2)||45!=this.input.charCodeAt(this.pos+3)?(61===e&&(s=2),this.finishOp(V.relational,s)):(this.skipLineComment(4),this.skipSpace(),this.nextToken())},ut.readToken_eq_excl=function(t){var e=this.input.charCodeAt(this.pos+1);return 61===e?this.finishOp(V.equality,61===this.input.charCodeAt(this.pos+2)?3:2):61===t&&62===e&&this.options.ecmaVersion>=6?(this.pos+=2,this.finishToken(V.arrow)):this.finishOp(61===t?V.eq:V.prefix,1)},ut.getTokenFromCode=function(t){switch(t){case 46:return this.readToken_dot();case 40:return++this.pos,this.finishToken(V.parenL);case 41:return++this.pos,this.finishToken(V.parenR);case 59:return++this.pos,this.finishToken(V.semi);case 44:return++this.pos,this.finishToken(V.comma);case 91:return++this.pos,this.finishToken(V.bracketL);case 93:return++this.pos,this.finishToken(V.bracketR);case 123:return++this.pos,this.finishToken(V.braceL);case 125:return++this.pos,this.finishToken(V.braceR);case 58:return++this.pos,this.finishToken(V.colon);case 63:return++this.pos,this.finishToken(V.question);case 96:if(this.options.ecmaVersion<6)break;return++this.pos,this.finishToken(V.backQuote);case 48:var e=this.input.charCodeAt(this.pos+1);if(120===e||88===e)return this.readRadixNumber(16);if(this.options.ecmaVersion>=6){if(111===e||79===e)return this.readRadixNumber(8);if(98===e||66===e)return this.readRadixNumber(2)}case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return this.readNumber(!1);case 34:case 39:return this.readString(t);case 47:return this.readToken_slash();case 37:case 42:return this.readToken_mult_modulo_exp(t);case 124:case 38:return this.readToken_pipe_amp(t);case 94:return this.readToken_caret();case 43:case 45:return this.readToken_plus_min(t);case 60:case 62:return this.readToken_lt_gt(t);case 61:case 33:return this.readToken_eq_excl(t);case 126:return this.finishOp(V.prefix,1)}this.raise(this.pos,"Unexpected character '"+m(t)+"'")},ut.finishOp=function(t,e){var s=this.input.slice(this.pos,this.pos+e);return this.pos+=e,this.finishToken(t,s)};var ft=!!f("￿","u");ut.readRegexp=function(){for(var t,e,s=this,i=this.pos;;){s.pos>=s.input.length&&s.raise(i,"Unterminated regular expression");var r=s.input.charAt(s.pos);if(F.test(r)&&s.raise(i,"Unterminated regular expression"),t)t=!1;else{if("["===r)e=!0;else if("]"===r&&e)e=!1;else if("/"===r&&!e)break;t="\\"===r}++s.pos}var n=this.input.slice(i,this.pos);++this.pos;var a=this.readWord1(),o=n,h="";if(a){var p=/^[gim]*$/;this.options.ecmaVersion>=6&&(p=/^[gimuy]*$/),this.options.ecmaVersion>=9&&(p=/^[gimsuy]*$/),p.test(a)||this.raise(i,"Invalid regular expression flag"),a.indexOf("u")>=0&&(ft?h="u":(o=o.replace(/\\u\{([0-9a-fA-F]+)\}/g,function(t,e,r){return e=Number("0x"+e),e>1114111&&s.raise(i+r+3,"Code point out of bounds"),"x"}),o=o.replace(/\\u([a-fA-F0-9]{4})|[\uD800-\uDBFF][\uDC00-\uDFFF]/g,"x"),h=h.replace("u","")))}var c=null;return dt||(f(o,h,i,this),c=f(n,a)),this.finishToken(V.regexp,{pattern:n,flags:a,value:c})},ut.readInt=function(t,e){for(var s=this,i=this.pos,r=0,n=0,a=null==e?1/0:e;n<a;++n){var o=s.input.charCodeAt(s.pos),h=void 0;if((h=o>=97?o-97+10:o>=65?o-65+10:o>=48&&o<=57?o-48:1/0)>=t)break;++s.pos,r=r*t+h}return this.pos===i||null!=e&&this.pos-i!==e?null:r},ut.readRadixNumber=function(t){this.pos+=2;var e=this.readInt(t);return null==e&&this.raise(this.start+2,"Expected number in radix "+t),s(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number"),this.finishToken(V.num,e)},ut.readNumber=function(t){var e=this.pos;t||null!==this.readInt(10)||this.raise(e,"Invalid number");var i=this.pos-e>=2&&48===this.input.charCodeAt(e);i&&this.strict&&this.raise(e,"Invalid number"),i&&/[89]/.test(this.input.slice(e,this.pos))&&(i=!1);var r=this.input.charCodeAt(this.pos)
+;46!==r||i||(++this.pos,this.readInt(10),r=this.input.charCodeAt(this.pos)),69!==r&&101!==r||i||(r=this.input.charCodeAt(++this.pos),43!==r&&45!==r||++this.pos,null===this.readInt(10)&&this.raise(e,"Invalid number")),s(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number");var n=this.input.slice(e,this.pos),a=i?parseInt(n,8):parseFloat(n);return this.finishToken(V.num,a)},ut.readCodePoint=function(){var t,e=this.input.charCodeAt(this.pos);if(123===e){this.options.ecmaVersion<6&&this.unexpected();var s=++this.pos;t=this.readHexChar(this.input.indexOf("}",this.pos)-this.pos),++this.pos,t>1114111&&this.invalidStringToken(s,"Code point out of bounds")}else t=this.readHexChar(4);return t},ut.readString=function(t){for(var e=this,s="",i=++this.pos;;){e.pos>=e.input.length&&e.raise(e.start,"Unterminated string constant");var r=e.input.charCodeAt(e.pos);if(r===t)break;92===r?(s+=e.input.slice(i,e.pos),s+=e.readEscapedChar(!1),i=e.pos):(a(r)&&e.raise(e.start,"Unterminated string constant"),++e.pos)}return s+=this.input.slice(i,this.pos++),this.finishToken(V.string,s)};var mt={};ut.tryReadTemplateToken=function(){this.inTemplateElement=!0;try{this.readTmplToken()}catch(t){if(t!==mt)throw t;this.readInvalidTemplateToken()}this.inTemplateElement=!1},ut.invalidStringToken=function(t,e){if(this.inTemplateElement&&this.options.ecmaVersion>=9)throw mt;this.raise(t,e)},ut.readTmplToken=function(){for(var t=this,e="",s=this.pos;;){t.pos>=t.input.length&&t.raise(t.start,"Unterminated template");var i=t.input.charCodeAt(t.pos);if(96===i||36===i&&123===t.input.charCodeAt(t.pos+1))return t.pos!==t.start||t.type!==V.template&&t.type!==V.invalidTemplate?(e+=t.input.slice(s,t.pos),t.finishToken(V.template,e)):36===i?(t.pos+=2,t.finishToken(V.dollarBraceL)):(++t.pos,t.finishToken(V.backQuote));if(92===i)e+=t.input.slice(s,t.pos),e+=t.readEscapedChar(!0),s=t.pos;else if(a(i)){switch(e+=t.input.slice(s,t.pos),++t.pos,i){case 13:10===t.input.charCodeAt(t.pos)&&++t.pos;case 10:e+="\n";break;default:e+=String.fromCharCode(i)}t.options.locations&&(++t.curLine,t.lineStart=t.pos),s=t.pos}else++t.pos}},ut.readInvalidTemplateToken=function(){for(var t=this;this.pos<this.input.length;this.pos++)switch(t.input[t.pos]){case"\\":++t.pos;break;case"$":if("{"!==t.input[t.pos+1])break;case"`":return t.finishToken(V.invalidTemplate,t.input.slice(t.start,t.pos))}this.raise(this.start,"Unterminated template")},ut.readEscapedChar=function(t){var e=this.input.charCodeAt(++this.pos);switch(++this.pos,e){case 110:return"\n";case 114:return"\r";case 120:return String.fromCharCode(this.readHexChar(2));case 117:return m(this.readCodePoint());case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===this.input.charCodeAt(this.pos)&&++this.pos;case 10:return this.options.locations&&(this.lineStart=this.pos,++this.curLine),"";default:if(e>=48&&e<=55){var s=this.input.substr(this.pos-1,3).match(/^[0-7]+/)[0],i=parseInt(s,8);return i>255&&(s=s.slice(0,-1),i=parseInt(s,8)),"0"!==s&&(this.strict||t)&&this.invalidStringToken(this.pos-2,"Octal literal in strict mode"),this.pos+=s.length-1,String.fromCharCode(i)}return String.fromCharCode(e)}},ut.readHexChar=function(t){var e=this.pos,s=this.readInt(16,t);return null===s&&this.invalidStringToken(e,"Bad character escape sequence"),s},ut.readWord1=function(){var t=this;this.containsEsc=!1;for(var e="",r=!0,n=this.pos,a=this.options.ecmaVersion>=6;this.pos<this.input.length;){var o=t.fullCharCodeAtPos();if(i(o,a))t.pos+=o<=65535?1:2;else{if(92!==o)break;t.containsEsc=!0,e+=t.input.slice(n,t.pos);var h=t.pos;117!=t.input.charCodeAt(++t.pos)&&t.invalidStringToken(t.pos,"Expecting Unicode escape sequence \\uXXXX"),++t.pos;var p=t.readCodePoint();(r?s:i)(p,a)||t.invalidStringToken(h,"Invalid Unicode escape"),e+=m(p),n=t.pos}r=!1}return e+this.input.slice(n,this.pos)},ut.readWord=function(){var t=this.readWord1(),e=V.name;return this.keywords.test(t)&&(this.containsEsc&&this.raiseRecoverable(this.start,"Escape sequence in keyword "+t),e=R[t]),this.finishToken(e,t)};t.version="5.3.0",t.parse=x,t.parseExpressionAt=y,t.tokenizer=v,t.addLooseExports=b,t.Parser=$,t.plugins=Y,t.defaultOptions=G,t.Position=j,t.SourceLocation=W,t.getLineInfo=h,t.Node=at,t.TokenType=T,t.tokTypes=V,t.keywordTypes=R,t.TokContext=ht,t.tokContexts=pt,t.isIdentifierChar=i,t.isIdentifierStart=s,t.Token=lt,t.isNewLine=a,t.lineBreak=F,t.lineBreakG=D,t.nonASCIIwhitespace=B,Object.defineProperty(t,"__esModule",{value:!0})});
 },{}],46:[function(require,module,exports){
-
+"use strict";function placeHoldersCount(o){var r=o.length;if(r%4>0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===o[r-2]?2:"="===o[r-1]?1:0}function byteLength(o){return 3*o.length/4-placeHoldersCount(o)}function toByteArray(o){var r,e,t,u,n,p=o.length;u=placeHoldersCount(o),n=new Arr(3*p/4-u),e=u>0?p-4:p;var a=0;for(r=0;r<e;r+=4)t=revLookup[o.charCodeAt(r)]<<18|revLookup[o.charCodeAt(r+1)]<<12|revLookup[o.charCodeAt(r+2)]<<6|revLookup[o.charCodeAt(r+3)],n[a++]=t>>16&255,n[a++]=t>>8&255,n[a++]=255&t;return 2===u?(t=revLookup[o.charCodeAt(r)]<<2|revLookup[o.charCodeAt(r+1)]>>4,n[a++]=255&t):1===u&&(t=revLookup[o.charCodeAt(r)]<<10|revLookup[o.charCodeAt(r+1)]<<4|revLookup[o.charCodeAt(r+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t),n}function tripletToBase64(o){return lookup[o>>18&63]+lookup[o>>12&63]+lookup[o>>6&63]+lookup[63&o]}function encodeChunk(o,r,e){for(var t,u=[],n=r;n<e;n+=3)t=(o[n]<<16)+(o[n+1]<<8)+o[n+2],u.push(tripletToBase64(t));return u.join("")}function fromByteArray(o){for(var r,e=o.length,t=e%3,u="",n=[],p=0,a=e-t;p<a;p+=16383)n.push(encodeChunk(o,p,p+16383>a?a:p+16383));return 1===t?(r=o[e-1],u+=lookup[r>>2],u+=lookup[r<<4&63],u+="=="):2===t&&(r=(o[e-2]<<8)+o[e-1],u+=lookup[r>>10],u+=lookup[r>>4&63],u+=lookup[r<<2&63],u+="="),n.push(u),n.join("")}exports.byteLength=byteLength,exports.toByteArray=toByteArray,exports.fromByteArray=fromByteArray;for(var lookup=[],revLookup=[],Arr="undefined"!=typeof Uint8Array?Uint8Array:Array,code="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,len=code.length;i<len;++i)lookup[i]=code[i],revLookup[code.charCodeAt(i)]=i;revLookup["-".charCodeAt(0)]=62,revLookup["_".charCodeAt(0)]=63;
 },{}],47:[function(require,module,exports){
+
+},{}],48:[function(require,module,exports){
 (function (global){
 "use strict";function typedArraySupport(){try{var t=new Uint8Array(1);return t.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===t.foo()&&"function"==typeof t.subarray&&0===t.subarray(1,1).byteLength}catch(t){return!1}}function kMaxLength(){return Buffer.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function createBuffer(t,e){if(kMaxLength()<e)throw new RangeError("Invalid typed array length");return Buffer.TYPED_ARRAY_SUPPORT?(t=new Uint8Array(e),t.__proto__=Buffer.prototype):(null===t&&(t=new Buffer(e)),t.length=e),t}function Buffer(t,e,r){if(!(Buffer.TYPED_ARRAY_SUPPORT||this instanceof Buffer))return new Buffer(t,e,r);if("number"==typeof t){if("string"==typeof e)throw new Error("If encoding is specified then the first argument must be a string");return allocUnsafe(this,t)}return from(this,t,e,r)}function from(t,e,r,n){if("number"==typeof e)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer?fromArrayBuffer(t,e,r,n):"string"==typeof e?fromString(t,e,r):fromObject(t,e)}function assertSize(t){if("number"!=typeof t)throw new TypeError('"size" argument must be a number');if(t<0)throw new RangeError('"size" argument must not be negative')}function alloc(t,e,r,n){return assertSize(e),e<=0?createBuffer(t,e):void 0!==r?"string"==typeof n?createBuffer(t,e).fill(r,n):createBuffer(t,e).fill(r):createBuffer(t,e)}function allocUnsafe(t,e){if(assertSize(e),t=createBuffer(t,e<0?0:0|checked(e)),!Buffer.TYPED_ARRAY_SUPPORT)for(var r=0;r<e;++r)t[r]=0;return t}function fromString(t,e,r){if("string"==typeof r&&""!==r||(r="utf8"),!Buffer.isEncoding(r))throw new TypeError('"encoding" must be a valid string encoding');var n=0|byteLength(e,r);t=createBuffer(t,n);var f=t.write(e,r);return f!==n&&(t=t.slice(0,f)),t}function fromArrayLike(t,e){var r=e.length<0?0:0|checked(e.length);t=createBuffer(t,r);for(var n=0;n<r;n+=1)t[n]=255&e[n];return t}function fromArrayBuffer(t,e,r,n){if(e.byteLength,r<0||e.byteLength<r)throw new RangeError("'offset' is out of bounds");if(e.byteLength<r+(n||0))throw new RangeError("'length' is out of bounds");return e=void 0===r&&void 0===n?new Uint8Array(e):void 0===n?new Uint8Array(e,r):new Uint8Array(e,r,n),Buffer.TYPED_ARRAY_SUPPORT?(t=e,t.__proto__=Buffer.prototype):t=fromArrayLike(t,e),t}function fromObject(t,e){if(Buffer.isBuffer(e)){var r=0|checked(e.length);return t=createBuffer(t,r),0===t.length?t:(e.copy(t,0,0,r),t)}if(e){if("undefined"!=typeof ArrayBuffer&&e.buffer instanceof ArrayBuffer||"length"in e)return"number"!=typeof e.length||isnan(e.length)?createBuffer(t,0):fromArrayLike(t,e);if("Buffer"===e.type&&isArray(e.data))return fromArrayLike(t,e.data)}throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}function checked(t){if(t>=kMaxLength())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+kMaxLength().toString(16)+" bytes");return 0|t}function SlowBuffer(t){return+t!=t&&(t=0),Buffer.alloc(+t)}function byteLength(t,e){if(Buffer.isBuffer(t))return t.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(t)||t instanceof ArrayBuffer))return t.byteLength;"string"!=typeof t&&(t=""+t);var r=t.length;if(0===r)return 0;for(var n=!1;;)switch(e){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return utf8ToBytes(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return base64ToBytes(t).length;default:if(n)return utf8ToBytes(t).length;e=(""+e).toLowerCase(),n=!0}}function slowToString(t,e,r){var n=!1;if((void 0===e||e<0)&&(e=0),e>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,e>>>=0,r<=e)return"";for(t||(t="utf8");;)switch(t){case"hex":return hexSlice(this,e,r);case"utf8":case"utf-8":return utf8Slice(this,e,r);case"ascii":return asciiSlice(this,e,r);case"latin1":case"binary":return latin1Slice(this,e,r);case"base64":return base64Slice(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}function swap(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function bidirectionalIndexOf(t,e,r,n,f){if(0===t.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=f?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(f)return-1;r=t.length-1}else if(r<0){if(!f)return-1;r=0}if("string"==typeof e&&(e=Buffer.from(e,n)),Buffer.isBuffer(e))return 0===e.length?-1:arrayIndexOf(t,e,r,n,f);if("number"==typeof e)return e&=255,Buffer.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?f?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):arrayIndexOf(t,[e],r,n,f);throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(t,e,r,n,f){function i(t,e){return 1===o?t[e]:t.readUInt16BE(e*o)}var o=1,u=t.length,s=e.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(t.length<2||e.length<2)return-1;o=2,u/=2,s/=2,r/=2}var a;if(f){var h=-1;for(a=r;a<u;a++)if(i(t,a)===i(e,-1===h?0:a-h)){if(-1===h&&(h=a),a-h+1===s)return h*o}else-1!==h&&(a-=a-h),h=-1}else for(r+s>u&&(r=u-s),a=r;a>=0;a--){for(var c=!0,l=0;l<s;l++)if(i(t,a+l)!==i(e,l)){c=!1;break}if(c)return a}return-1}function hexWrite(t,e,r,n){r=Number(r)||0;var f=t.length-r;n?(n=Number(n))>f&&(n=f):n=f;var i=e.length;if(i%2!=0)throw new TypeError("Invalid hex string");n>i/2&&(n=i/2);for(var o=0;o<n;++o){var u=parseInt(e.substr(2*o,2),16);if(isNaN(u))return o;t[r+o]=u}return o}function utf8Write(t,e,r,n){return blitBuffer(utf8ToBytes(e,t.length-r),t,r,n)}function asciiWrite(t,e,r,n){return blitBuffer(asciiToBytes(e),t,r,n)}function latin1Write(t,e,r,n){return asciiWrite(t,e,r,n)}function base64Write(t,e,r,n){return blitBuffer(base64ToBytes(e),t,r,n)}function ucs2Write(t,e,r,n){return blitBuffer(utf16leToBytes(e,t.length-r),t,r,n)}function base64Slice(t,e,r){return 0===e&&r===t.length?base64.fromByteArray(t):base64.fromByteArray(t.slice(e,r))}function utf8Slice(t,e,r){r=Math.min(t.length,r);for(var n=[],f=e;f<r;){var i=t[f],o=null,u=i>239?4:i>223?3:i>191?2:1;if(f+u<=r){var s,a,h,c;switch(u){case 1:i<128&&(o=i);break;case 2:s=t[f+1],128==(192&s)&&(c=(31&i)<<6|63&s)>127&&(o=c);break;case 3:s=t[f+1],a=t[f+2],128==(192&s)&&128==(192&a)&&(c=(15&i)<<12|(63&s)<<6|63&a)>2047&&(c<55296||c>57343)&&(o=c);break;case 4:s=t[f+1],a=t[f+2],h=t[f+3],128==(192&s)&&128==(192&a)&&128==(192&h)&&(c=(15&i)<<18|(63&s)<<12|(63&a)<<6|63&h)>65535&&c<1114112&&(o=c)}}null===o?(o=65533,u=1):o>65535&&(o-=65536,n.push(o>>>10&1023|55296),o=56320|1023&o),n.push(o),f+=u}return decodeCodePointsArray(n)}function decodeCodePointsArray(t){var e=t.length;if(e<=MAX_ARGUMENTS_LENGTH)return String.fromCharCode.apply(String,t);for(var r="",n=0;n<e;)r+=String.fromCharCode.apply(String,t.slice(n,n+=MAX_ARGUMENTS_LENGTH));return r}function asciiSlice(t,e,r){var n="";r=Math.min(t.length,r);for(var f=e;f<r;++f)n+=String.fromCharCode(127&t[f]);return n}function latin1Slice(t,e,r){var n="";r=Math.min(t.length,r);for(var f=e;f<r;++f)n+=String.fromCharCode(t[f]);return n}function hexSlice(t,e,r){var n=t.length;(!e||e<0)&&(e=0),(!r||r<0||r>n)&&(r=n);for(var f="",i=e;i<r;++i)f+=toHex(t[i]);return f}function utf16leSlice(t,e,r){for(var n=t.slice(e,r),f="",i=0;i<n.length;i+=2)f+=String.fromCharCode(n[i]+256*n[i+1]);return f}function checkOffset(t,e,r){if(t%1!=0||t<0)throw new RangeError("offset is not uint");if(t+e>r)throw new RangeError("Trying to access beyond buffer length")}function checkInt(t,e,r,n,f,i){if(!Buffer.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>f||e<i)throw new RangeError('"value" argument is out of bounds');if(r+n>t.length)throw new RangeError("Index out of range")}function objectWriteUInt16(t,e,r,n){e<0&&(e=65535+e+1);for(var f=0,i=Math.min(t.length-r,2);f<i;++f)t[r+f]=(e&255<<8*(n?f:1-f))>>>8*(n?f:1-f)}function objectWriteUInt32(t,e,r,n){e<0&&(e=4294967295+e+1);for(var f=0,i=Math.min(t.length-r,4);f<i;++f)t[r+f]=e>>>8*(n?f:3-f)&255}function checkIEEE754(t,e,r,n,f,i){if(r+n>t.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function writeFloat(t,e,r,n,f){return f||checkIEEE754(t,e,r,4,3.4028234663852886e38,-3.4028234663852886e38),ieee754.write(t,e,r,n,23,4),r+4}function writeDouble(t,e,r,n,f){return f||checkIEEE754(t,e,r,8,1.7976931348623157e308,-1.7976931348623157e308),ieee754.write(t,e,r,n,52,8),r+8}function base64clean(t){if(t=stringtrim(t).replace(INVALID_BASE64_RE,""),t.length<2)return"";for(;t.length%4!=0;)t+="=";return t}function stringtrim(t){return t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")}function toHex(t){return t<16?"0"+t.toString(16):t.toString(16)}function utf8ToBytes(t,e){e=e||1/0;for(var r,n=t.length,f=null,i=[],o=0;o<n;++o){if((r=t.charCodeAt(o))>55295&&r<57344){if(!f){if(r>56319){(e-=3)>-1&&i.push(239,191,189);continue}if(o+1===n){(e-=3)>-1&&i.push(239,191,189);continue}f=r;continue}if(r<56320){(e-=3)>-1&&i.push(239,191,189),f=r;continue}r=65536+(f-55296<<10|r-56320)}else f&&(e-=3)>-1&&i.push(239,191,189);if(f=null,r<128){if((e-=1)<0)break;i.push(r)}else if(r<2048){if((e-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((e-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function asciiToBytes(t){for(var e=[],r=0;r<t.length;++r)e.push(255&t.charCodeAt(r));return e}function utf16leToBytes(t,e){for(var r,n,f,i=[],o=0;o<t.length&&!((e-=2)<0);++o)r=t.charCodeAt(o),n=r>>8,f=r%256,i.push(f),i.push(n);return i}function base64ToBytes(t){return base64.toByteArray(base64clean(t))}function blitBuffer(t,e,r,n){for(var f=0;f<n&&!(f+r>=e.length||f>=t.length);++f)e[f+r]=t[f];return f}function isnan(t){return t!==t}var base64=require("base64-js"),ieee754=require("ieee754"),isArray=require("isarray");exports.Buffer=Buffer,exports.SlowBuffer=SlowBuffer,exports.INSPECT_MAX_BYTES=50,Buffer.TYPED_ARRAY_SUPPORT=void 0!==global.TYPED_ARRAY_SUPPORT?global.TYPED_ARRAY_SUPPORT:typedArraySupport(),exports.kMaxLength=kMaxLength(),Buffer.poolSize=8192,Buffer._augment=function(t){return t.__proto__=Buffer.prototype,t},Buffer.from=function(t,e,r){return from(null,t,e,r)},Buffer.TYPED_ARRAY_SUPPORT&&(Buffer.prototype.__proto__=Uint8Array.prototype,Buffer.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&Buffer[Symbol.species]===Buffer&&Object.defineProperty(Buffer,Symbol.species,{value:null,configurable:!0})),Buffer.alloc=function(t,e,r){return alloc(null,t,e,r)},Buffer.allocUnsafe=function(t){return allocUnsafe(null,t)},Buffer.allocUnsafeSlow=function(t){return allocUnsafe(null,t)},Buffer.isBuffer=function(t){return!(null==t||!t._isBuffer)},Buffer.compare=function(t,e){if(!Buffer.isBuffer(t)||!Buffer.isBuffer(e))throw new TypeError("Arguments must be Buffers");if(t===e)return 0;for(var r=t.length,n=e.length,f=0,i=Math.min(r,n);f<i;++f)if(t[f]!==e[f]){r=t[f],n=e[f];break}return r<n?-1:n<r?1:0},Buffer.isEncoding=function(t){switch(String(t).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},Buffer.concat=function(t,e){if(!isArray(t))throw new TypeError('"list" argument must be an Array of Buffers');if(0===t.length)return Buffer.alloc(0);var r;if(void 0===e)for(e=0,r=0;r<t.length;++r)e+=t[r].length;var n=Buffer.allocUnsafe(e),f=0;for(r=0;r<t.length;++r){var i=t[r];if(!Buffer.isBuffer(i))throw new TypeError('"list" argument must be an Array of Buffers');i.copy(n,f),f+=i.length}return n},Buffer.byteLength=byteLength,Buffer.prototype._isBuffer=!0,Buffer.prototype.swap16=function(){var t=this.length;if(t%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var e=0;e<t;e+=2)swap(this,e,e+1);return this},Buffer.prototype.swap32=function(){var t=this.length;if(t%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var e=0;e<t;e+=4)swap(this,e,e+3),swap(this,e+1,e+2);return this},Buffer.prototype.swap64=function(){var t=this.length;if(t%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var e=0;e<t;e+=8)swap(this,e,e+7),swap(this,e+1,e+6),swap(this,e+2,e+5),swap(this,e+3,e+4);return this},Buffer.prototype.toString=function(){var t=0|this.length;return 0===t?"":0===arguments.length?utf8Slice(this,0,t):slowToString.apply(this,arguments)},Buffer.prototype.equals=function(t){if(!Buffer.isBuffer(t))throw new TypeError("Argument must be a Buffer");return this===t||0===Buffer.compare(this,t)},Buffer.prototype.inspect=function(){var t="",e=exports.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString("hex",0,e).match(/.{2}/g).join(" "),this.length>e&&(t+=" ... ")),"<Buffer "+t+">"},Buffer.prototype.compare=function(t,e,r,n,f){if(!Buffer.isBuffer(t))throw new TypeError("Argument must be a Buffer");if(void 0===e&&(e=0),void 0===r&&(r=t?t.length:0),void 0===n&&(n=0),void 0===f&&(f=this.length),e<0||r>t.length||n<0||f>this.length)throw new RangeError("out of range index");if(n>=f&&e>=r)return 0;if(n>=f)return-1;if(e>=r)return 1;if(e>>>=0,r>>>=0,n>>>=0,f>>>=0,this===t)return 0;for(var i=f-n,o=r-e,u=Math.min(i,o),s=this.slice(n,f),a=t.slice(e,r),h=0;h<u;++h)if(s[h]!==a[h]){i=s[h],o=a[h];break}return i<o?-1:o<i?1:0},Buffer.prototype.includes=function(t,e,r){return-1!==this.indexOf(t,e,r)},Buffer.prototype.indexOf=function(t,e,r){return bidirectionalIndexOf(this,t,e,r,!0)},Buffer.prototype.lastIndexOf=function(t,e,r){return bidirectionalIndexOf(this,t,e,r,!1)},Buffer.prototype.write=function(t,e,r,n){if(void 0===e)n="utf8",r=this.length,e=0;else if(void 0===r&&"string"==typeof e)n=e,r=this.length,e=0;else{if(!isFinite(e))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");e|=0,isFinite(r)?(r|=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var f=this.length-e;if((void 0===r||r>f)&&(r=f),t.length>0&&(r<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var i=!1;;)switch(n){case"hex":return hexWrite(this,t,e,r);case"utf8":case"utf-8":return utf8Write(this,t,e,r);case"ascii":return asciiWrite(this,t,e,r);case"latin1":case"binary":return latin1Write(this,t,e,r);case"base64":return base64Write(this,t,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,t,e,r);default:if(i)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),i=!0}},Buffer.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var MAX_ARGUMENTS_LENGTH=4096;Buffer.prototype.slice=function(t,e){var r=this.length;t=~~t,e=void 0===e?r:~~e,t<0?(t+=r)<0&&(t=0):t>r&&(t=r),e<0?(e+=r)<0&&(e=0):e>r&&(e=r),e<t&&(e=t);var n;if(Buffer.TYPED_ARRAY_SUPPORT)n=this.subarray(t,e),n.__proto__=Buffer.prototype;else{var f=e-t;n=new Buffer(f,void 0);for(var i=0;i<f;++i)n[i]=this[i+t]}return n},Buffer.prototype.readUIntLE=function(t,e,r){t|=0,e|=0,r||checkOffset(t,e,this.length);for(var n=this[t],f=1,i=0;++i<e&&(f*=256);)n+=this[t+i]*f;return n},Buffer.prototype.readUIntBE=function(t,e,r){t|=0,e|=0,r||checkOffset(t,e,this.length);for(var n=this[t+--e],f=1;e>0&&(f*=256);)n+=this[t+--e]*f;return n},Buffer.prototype.readUInt8=function(t,e){return e||checkOffset(t,1,this.length),this[t]},Buffer.prototype.readUInt16LE=function(t,e){return e||checkOffset(t,2,this.length),this[t]|this[t+1]<<8},Buffer.prototype.readUInt16BE=function(t,e){return e||checkOffset(t,2,this.length),this[t]<<8|this[t+1]},Buffer.prototype.readUInt32LE=function(t,e){return e||checkOffset(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},Buffer.prototype.readUInt32BE=function(t,e){return e||checkOffset(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},Buffer.prototype.readIntLE=function(t,e,r){t|=0,e|=0,r||checkOffset(t,e,this.length);for(var n=this[t],f=1,i=0;++i<e&&(f*=256);)n+=this[t+i]*f;return f*=128,n>=f&&(n-=Math.pow(2,8*e)),n},Buffer.prototype.readIntBE=function(t,e,r){t|=0,e|=0,r||checkOffset(t,e,this.length);for(var n=e,f=1,i=this[t+--n];n>0&&(f*=256);)i+=this[t+--n]*f;return f*=128,i>=f&&(i-=Math.pow(2,8*e)),i},Buffer.prototype.readInt8=function(t,e){return e||checkOffset(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},Buffer.prototype.readInt16LE=function(t,e){e||checkOffset(t,2,this.length);var r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},Buffer.prototype.readInt16BE=function(t,e){e||checkOffset(t,2,this.length);var r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},Buffer.prototype.readInt32LE=function(t,e){return e||checkOffset(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},Buffer.prototype.readInt32BE=function(t,e){return e||checkOffset(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},Buffer.prototype.readFloatLE=function(t,e){return e||checkOffset(t,4,this.length),ieee754.read(this,t,!0,23,4)},Buffer.prototype.readFloatBE=function(t,e){return e||checkOffset(t,4,this.length),ieee754.read(this,t,!1,23,4)},Buffer.prototype.readDoubleLE=function(t,e){return e||checkOffset(t,8,this.length),ieee754.read(this,t,!0,52,8)},Buffer.prototype.readDoubleBE=function(t,e){return e||checkOffset(t,8,this.length),ieee754.read(this,t,!1,52,8)},Buffer.prototype.writeUIntLE=function(t,e,r,n){if(t=+t,e|=0,r|=0,!n){checkInt(this,t,e,r,Math.pow(2,8*r)-1,0)}var f=1,i=0;for(this[e]=255&t;++i<r&&(f*=256);)this[e+i]=t/f&255;return e+r},Buffer.prototype.writeUIntBE=function(t,e,r,n){if(t=+t,e|=0,r|=0,!n){checkInt(this,t,e,r,Math.pow(2,8*r)-1,0)}var f=r-1,i=1;for(this[e+f]=255&t;--f>=0&&(i*=256);)this[e+f]=t/i&255;return e+r},Buffer.prototype.writeUInt8=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,1,255,0),Buffer.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),this[e]=255&t,e+1},Buffer.prototype.writeUInt16LE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,2,65535,0),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):objectWriteUInt16(this,t,e,!0),e+2},Buffer.prototype.writeUInt16BE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,2,65535,0),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):objectWriteUInt16(this,t,e,!1),e+2},Buffer.prototype.writeUInt32LE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t):objectWriteUInt32(this,t,e,!0),e+4},Buffer.prototype.writeUInt32BE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):objectWriteUInt32(this,t,e,!1),e+4},Buffer.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e|=0,!n){var f=Math.pow(2,8*r-1);checkInt(this,t,e,r,f-1,-f)}var i=0,o=1,u=0;for(this[e]=255&t;++i<r&&(o*=256);)t<0&&0===u&&0!==this[e+i-1]&&(u=1),this[e+i]=(t/o>>0)-u&255;return e+r},Buffer.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e|=0,!n){var f=Math.pow(2,8*r-1);checkInt(this,t,e,r,f-1,-f)}var i=r-1,o=1,u=0;for(this[e+i]=255&t;--i>=0&&(o*=256);)t<0&&0===u&&0!==this[e+i+1]&&(u=1),this[e+i]=(t/o>>0)-u&255;return e+r},Buffer.prototype.writeInt8=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,1,127,-128),Buffer.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),t<0&&(t=255+t+1),this[e]=255&t,e+1},Buffer.prototype.writeInt16LE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):objectWriteUInt16(this,t,e,!0),e+2},Buffer.prototype.writeInt16BE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):objectWriteUInt16(this,t,e,!1),e+2},Buffer.prototype.writeInt32LE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,4,2147483647,-2147483648),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24):objectWriteUInt32(this,t,e,!0),e+4},Buffer.prototype.writeInt32BE=function(t,e,r){return t=+t,e|=0,r||checkInt(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),Buffer.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):objectWriteUInt32(this,t,e,!1),e+4},Buffer.prototype.writeFloatLE=function(t,e,r){return writeFloat(this,t,e,!0,r)},Buffer.prototype.writeFloatBE=function(t,e,r){return writeFloat(this,t,e,!1,r)},Buffer.prototype.writeDoubleLE=function(t,e,r){return writeDouble(this,t,e,!0,r)},Buffer.prototype.writeDoubleBE=function(t,e,r){return writeDouble(this,t,e,!1,r)},Buffer.prototype.copy=function(t,e,r,n){if(r||(r=0),n||0===n||(n=this.length),e>=t.length&&(e=t.length),e||(e=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===t.length||0===this.length)return 0;if(e<0)throw new RangeError("targetStart out of bounds");if(r<0||r>=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),t.length-e<n-r&&(n=t.length-e+r);var f,i=n-r;if(this===t&&r<e&&e<n)for(f=i-1;f>=0;--f)t[f+e]=this[f+r];else if(i<1e3||!Buffer.TYPED_ARRAY_SUPPORT)for(f=0;f<i;++f)t[f+e]=this[f+r];else Uint8Array.prototype.set.call(t,this.subarray(r,r+i),e);return i},Buffer.prototype.fill=function(t,e,r,n){if("string"==typeof t){if("string"==typeof e?(n=e,e=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),1===t.length){var f=t.charCodeAt(0);f<256&&(t=f)}if(void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!Buffer.isEncoding(n))throw new TypeError("Unknown encoding: "+n)}else"number"==typeof t&&(t&=255);if(e<0||this.length<e||this.length<r)throw new RangeError("Out of range index");if(r<=e)return this;e>>>=0,r=void 0===r?this.length:r>>>0,t||(t=0);var i;if("number"==typeof t)for(i=e;i<r;++i)this[i]=t;else{var o=Buffer.isBuffer(t)?t:utf8ToBytes(new Buffer(t,n).toString()),u=o.length;for(i=0;i<r-e;++i)this[i+e]=o[i%u]}return this};var INVALID_BASE64_RE=/[^+\/0-9A-Za-z-_]/g;
 
 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"base64-js":45,"ieee754":77,"isarray":80}],48:[function(require,module,exports){
+},{"base64-js":46,"ieee754":77,"isarray":80}],49:[function(require,module,exports){
 (function (Buffer){
 function isArray(r){return Array.isArray?Array.isArray(r):"[object Array]"===objectToString(r)}function isBoolean(r){return"boolean"==typeof r}function isNull(r){return null===r}function isNullOrUndefined(r){return null==r}function isNumber(r){return"number"==typeof r}function isString(r){return"string"==typeof r}function isSymbol(r){return"symbol"==typeof r}function isUndefined(r){return void 0===r}function isRegExp(r){return"[object RegExp]"===objectToString(r)}function isObject(r){return"object"==typeof r&&null!==r}function isDate(r){return"[object Date]"===objectToString(r)}function isError(r){return"[object Error]"===objectToString(r)||r instanceof Error}function isFunction(r){return"function"==typeof r}function isPrimitive(r){return null===r||"boolean"==typeof r||"number"==typeof r||"string"==typeof r||"symbol"==typeof r||void 0===r}function objectToString(r){return Object.prototype.toString.call(r)}exports.isArray=isArray,exports.isBoolean=isBoolean,exports.isNull=isNull,exports.isNullOrUndefined=isNullOrUndefined,exports.isNumber=isNumber,exports.isString=isString,exports.isSymbol=isSymbol,exports.isUndefined=isUndefined,exports.isRegExp=isRegExp,exports.isObject=isObject,exports.isDate=isDate,exports.isError=isError,exports.isFunction=isFunction,exports.isPrimitive=isPrimitive,exports.isBuffer=Buffer.isBuffer;
 
 }).call(this,{"isBuffer":require("../../is-buffer/index.js")})
-},{"../../is-buffer/index.js":79}],49:[function(require,module,exports){
+},{"../../is-buffer/index.js":79}],50:[function(require,module,exports){
 function EventEmitter(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function isFunction(e){return"function"==typeof e}function isNumber(e){return"number"==typeof e}function isObject(e){return"object"==typeof e&&null!==e}function isUndefined(e){return void 0===e}module.exports=EventEmitter,EventEmitter.EventEmitter=EventEmitter,EventEmitter.prototype._events=void 0,EventEmitter.prototype._maxListeners=void 0,EventEmitter.defaultMaxListeners=10,EventEmitter.prototype.setMaxListeners=function(e){if(!isNumber(e)||e<0||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},EventEmitter.prototype.emit=function(e){var t,i,n,s,r,o;if(this._events||(this._events={}),"error"===e&&(!this._events.error||isObject(this._events.error)&&!this._events.error.length)){if((t=arguments[1])instanceof Error)throw t;var h=new Error('Uncaught, unspecified "error" event. ('+t+")");throw h.context=t,h}if(i=this._events[e],isUndefined(i))return!1;if(isFunction(i))switch(arguments.length){case 1:i.call(this);break;case 2:i.call(this,arguments[1]);break;case 3:i.call(this,arguments[1],arguments[2]);break;default:s=Array.prototype.slice.call(arguments,1),i.apply(this,s)}else if(isObject(i))for(s=Array.prototype.slice.call(arguments,1),o=i.slice(),n=o.length,r=0;r<n;r++)o[r].apply(this,s);return!0},EventEmitter.prototype.addListener=function(e,t){var i;if(!isFunction(t))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,isFunction(t.listener)?t.listener:t),this._events[e]?isObject(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,isObject(this._events[e])&&!this._events[e].warned&&(i=isUndefined(this._maxListeners)?EventEmitter.defaultMaxListeners:this._maxListeners)&&i>0&&this._events[e].length>i&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},EventEmitter.prototype.on=EventEmitter.prototype.addListener,EventEmitter.prototype.once=function(e,t){function i(){this.removeListener(e,i),n||(n=!0,t.apply(this,arguments))}if(!isFunction(t))throw TypeError("listener must be a function");var n=!1;return i.listener=t,this.on(e,i),this},EventEmitter.prototype.removeListener=function(e,t){var i,n,s,r;if(!isFunction(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(i=this._events[e],s=i.length,n=-1,i===t||isFunction(i.listener)&&i.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(isObject(i)){for(r=s;r-- >0;)if(i[r]===t||i[r].listener&&i[r].listener===t){n=r;break}if(n<0)return this;1===i.length?(i.length=0,delete this._events[e]):i.splice(n,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},EventEmitter.prototype.removeAllListeners=function(e){var t,i;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(i=this._events[e],isFunction(i))this.removeListener(e,i);else if(i)for(;i.length;)this.removeListener(e,i[i.length-1]);return delete this._events[e],this},EventEmitter.prototype.listeners=function(e){return this._events&&this._events[e]?isFunction(this._events[e])?[this._events[e]]:this._events[e].slice():[]},EventEmitter.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(isFunction(t))return 1;if(t)return t.length}return 0},EventEmitter.listenerCount=function(e,t){return e.listenerCount(t)};
-},{}],50:[function(require,module,exports){
+},{}],51:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var _createClass=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),FunctionBuilderBase=require("../function-builder-base"),CPUFunctionNode=require("./function-node");module.exports=function(e){function t(){_classCallCheck(this,t);var e=_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).call(this));return e.Node=CPUFunctionNode,e}return _inherits(t,e),_createClass(t,[{key:"polyfillStandardFunctions",value:function(){}}]),t}(FunctionBuilderBase);
 
-},{"../function-builder-base":55,"./function-node":51}],51:[function(require,module,exports){
+},{"../function-builder-base":56,"./function-node":52}],52:[function(require,module,exports){
 "use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}function _inherits(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}var _createClass=function(){function t(t,e){for(var s=0;s<e.length;s++){var n=e[s];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}return function(e,s,n){return s&&t(e.prototype,s),n&&t(e,n),e}}(),BaseFunctionNode=require("../function-node-base"),utils=require("../../core/utils");module.exports=function(t){function e(){return _classCallCheck(this,e),_possibleConstructorReturn(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return _inherits(e,t),_createClass(e,[{key:"generate",value:function(){return this.debug&&console.log(this),this.functionStringArray=this.astGeneric(this.getJsAST(),[],this),this.functionString=this.functionStringArray.join("").trim(),this.functionString}},{key:"getFunctionPrototypeString",value:function(){return this.webGlFunctionPrototypeString?this.webGlFunctionPrototypeString:this.webGlFunctionPrototypeString=this.generate()}},{key:"astGeneric",value:function(t,e,s){if(null===t)throw this.astErrorOutput("NULL ast",t,s);if(Array.isArray(t)){for(var n=0;n<t.length;n++)this.astGeneric(t[n],e,s);return e}switch(t.type){case"FunctionDeclaration":return this.astFunctionDeclaration(t,e,s);case"FunctionExpression":return this.astFunctionExpression(t,e,s);case"ReturnStatement":return this.astReturnStatement(t,e,s);case"Literal":return this.astLiteral(t,e,s);case"BinaryExpression":return this.astBinaryExpression(t,e,s);case"Identifier":return this.astIdentifierExpression(t,e,s);case"AssignmentExpression":return this.astAssignmentExpression(t,e,s);case"ExpressionStatement":return this.astExpressionStatement(t,e,s);case"EmptyStatement":return this.astEmptyStatement(t,e,s);case"BlockStatement":return this.astBlockStatement(t,e,s);case"IfStatement":return this.astIfStatement(t,e,s);case"BreakStatement":return this.astBreakStatement(t,e,s);case"ContinueStatement":return this.astContinueStatement(t,e,s);case"ForStatement":return this.astForStatement(t,e,s);case"WhileStatement":return this.astWhileStatement(t,e,s);case"VariableDeclaration":return this.astVariableDeclaration(t,e,s);case"VariableDeclarator":return this.astVariableDeclarator(t,e,s);case"ThisExpression":return this.astThisExpression(t,e,s);case"SequenceExpression":return this.astSequenceExpression(t,e,s);case"UnaryExpression":return this.astUnaryExpression(t,e,s);case"UpdateExpression":return this.astUpdateExpression(t,e,s);case"LogicalExpression":return this.astLogicalExpression(t,e,s);case"MemberExpression":return this.astMemberExpression(t,e,s);case"CallExpression":return this.astCallExpression(t,e,s);case"ArrayExpression":return this.astArrayExpression(t,e,s);case"DebuggerStatement":return this.astDebuggerStatement(t,e,s)}throw this.astErrorOutput("Unknown ast type : "+t.type,t,s)}},{key:"astFunctionDeclaration",value:function(t,e,s){return this.addFunction&&this.addFunction(null,utils.getAstString(this.jsFunctionString,t)),e}},{key:"astFunctionExpression",value:function(t,e,s){if(!s.isRootKernel){e.push("function"),s.kernalAst=t,e.push(" "),e.push(s.functionName),e.push("(");for(var n=0;n<s.paramNames.length;++n){var r=s.paramNames[n];n>0&&e.push(", "),e.push(" "),e.push("user_"),e.push(r)}e.push(") {\n")}for(var a=0;a<t.body.body.length;++a)this.astGeneric(t.body.body[a],e,s),e.push("\n");return s.isRootKernel||e.push("}\n"),e}},{key:"astReturnStatement",value:function(t,e,s){return s.isRootKernel?(e.push("kernelResult = "),this.astGeneric(t.argument,e,s),e.push(";")):s.isSubKernel?(e.push(s.functionName+"Result = "),this.astGeneric(t.argument,e,s),e.push(";"),e.push("return "+s.functionName+"Result;")):(e.push("return "),this.astGeneric(t.argument,e,s),e.push(";")),e}},{key:"astLiteral",value:function(t,e,s){if(isNaN(t.value))throw this.astErrorOutput("Non-numeric literal not supported : "+t.value,t,s);return e.push(t.value),e}},{key:"astBinaryExpression",value:function(t,e,s){return e.push("("),this.astGeneric(t.left,e,s),e.push(t.operator),this.astGeneric(t.right,e,s),e.push(")"),e}},{key:"astIdentifierExpression",value:function(t,e,s){if("Identifier"!==t.type)throw this.astErrorOutput("IdentifierExpression - not an Identifier",t,s);switch(t.name){case"gpu_threadX":e.push("threadId.x");break;case"gpu_threadY":e.push("threadId.y");break;case"gpu_threadZ":e.push("threadId.z");break;case"gpu_outputX":e.push("uOutputDim.x");break;case"gpu_outputY":e.push("uOutputDim.y");break;case"gpu_outputZ":e.push("uOutputDim.z");break;default:if(this.constants&&this.constants.hasOwnProperty(t.name))e.push("constants_"+t.name);else{var n=s.getUserParamName(t.name);null!==n?e.push("user_"+n):e.push("user_"+t.name)}}return e}},{key:"astForStatement",value:function(t,e,s){if("ForStatement"!==t.type)throw this.astErrorOutput("Invalid for statment",t,s);if(t.test&&"BinaryExpression"===t.test.type){if(("Identifier"===t.test.right.type||"Literal"===t.test.right.type)&&"<"===t.test.operator&&!1===this.isIdentifierConstant(t.test.right.name)){if(this.loopMaxIterations||(console.warn("Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior."),console.warn("Set loopMaxIterations or use a for loop of fixed length to silence this message.")),e.push("for ("),this.astGeneric(t.init,e,s),";"!==e[e.length-1]&&e.push(";"),this.astGeneric(t.test.left,e,s),e.push(t.test.operator),e.push("LOOP_MAX"),e.push(";"),this.astGeneric(t.update,e,s),e.push(")"),e.push("{\n"),e.push("if ("),this.astGeneric(t.test.left,e,s),e.push(t.test.operator),this.astGeneric(t.test.right,e,s),e.push(") {\n"),"BlockStatement"===t.body.type)for(var n=0;n<t.body.body.length;n++)this.astGeneric(t.body.body[n],e,s);else this.astGeneric(t.body,e,s);return e.push("} else {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}if(t.init.declarations){var r=JSON.parse(JSON.stringify(t.init.declarations)),a=t.update.argument;if(!Array.isArray(r)||r.length<1)throw console.log(this.jsFunctionString),new Error("Error: Incompatible for loop declaration");if(r.length>1){for(var i=null,u=0;u<r.length;u++){var o=r[u];o.id.name===a.name?(i=o,r.splice(u,1)):(e.push("var "),this.astGeneric(o,e,s),e.push(";"))}e.push("for (let "),this.astGeneric(i,e,s),e.push(";")}else e.push("for ("),this.astGeneric(t.init,e,s);return this.astGeneric(t.test,e,s),e.push(";"),this.astGeneric(t.update,e,s),e.push(")"),this.astGeneric(t.body,e,s),e}}throw this.astErrorOutput("Invalid for statement",t,s)}},{key:"astWhileStatement",value:function(t,e,s){if("WhileStatement"!==t.type)throw this.astErrorOutput("Invalid while statment",t,s);return e.push("for (let i = 0; i < LOOP_MAX; i++) {"),e.push("if ("),this.astGeneric(t.test,e,s),e.push(") {\n"),this.astGeneric(t.body,e,s),e.push("} else {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}},{key:"astAssignmentExpression",value:function(t,e,s){return this.astGeneric(t.left,e,s),e.push(t.operator),this.astGeneric(t.right,e,s),e}},{key:"astEmptyStatement",value:function(t,e,s){return e}},{key:"astBlockStatement",value:function(t,e,s){e.push("{\n");for(var n=0;n<t.body.length;n++)this.astGeneric(t.body[n],e,s);return e.push("}\n"),e}},{key:"astExpressionStatement",value:function(t,e,s){return this.astGeneric(t.expression,e,s),e.push(";\n"),e}},{key:"astVariableDeclaration",value:function(t,e,s){e.push("var ");for(var n=0;n<t.declarations.length;n++)n>0&&e.push(","),this.astGeneric(t.declarations[n],e,s);return e.push(";"),e}},{key:"astVariableDeclarator",value:function(t,e,s){return this.astGeneric(t.id,e,s),null!==t.init&&(e.push("="),this.astGeneric(t.init,e,s)),e}},{key:"astIfStatement",value:function(t,e,s){return e.push("if ("),this.astGeneric(t.test,e,s),e.push(")"),"BlockStatement"===t.consequent.type?this.astGeneric(t.consequent,e,s):(e.push(" {\n"),this.astGeneric(t.consequent,e,s),e.push("\n}\n")),t.alternate&&(e.push("else "),"BlockStatement"===t.alternate.type?this.astGeneric(t.alternate,e,s):(e.push(" {\n"),this.astGeneric(t.alternate,e,s),e.push("\n}\n"))),e}},{key:"astBreakStatement",value:function(t,e,s){return e.push("break;\n"),e}},{key:"astContinueStatement",value:function(t,e,s){return e.push("continue;\n"),e}},{key:"astLogicalExpression",value:function(t,e,s){return e.push("("),this.astGeneric(t.left,e,s),e.push(t.operator),this.astGeneric(t.right,e,s),e.push(")"),e}},{key:"astUpdateExpression",value:function(t,e,s){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e,s)):(this.astGeneric(t.argument,e,s),e.push(t.operator)),e}},{key:"astUnaryExpression",value:function(t,e,s){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e,s)):(this.astGeneric(t.argument,e,s),e.push(t.operator)),e}},{key:"astThisExpression",value:function(t,e,s){return e.push("_this"),e}},{key:"astMemberExpression",value:function(t,e,s){if(t.computed)if("Identifier"===t.object.type)this.astGeneric(t.object,e,s),e.push("["),this.astGeneric(t.property,e,s),e.push("]");else{this.astGeneric(t.object,e,s);var n=e.pop();e.push("]["),this.astGeneric(t.property,e,s),e.push(n)}else{var r=this.astMemberExpressionUnroll(t);switch("Identifier"===t.property.type&&t.computed&&(r="user_"+r),0===r.indexOf("this")&&(r="_"+r),r){case"_this.output.x":e.push(this.output[0]);break;case"_this.output.y":e.push(this.output[1]);break;case"_this.output.z":e.push(this.output[2]);break;default:e.push(r)}}return e}},{key:"astSequenceExpression",value:function(t,e,s){for(var n=0;n<t.expressions.length;n++)n>0&&e.push(","),this.astGeneric(t.expressions,e,s);return e}},{key:"astCallExpression",value:function(t,e,s){if(t.callee){var n=this.astMemberExpressionUnroll(t.callee);s.calledFunctions.indexOf(n)<0&&s.calledFunctions.push(n),s.hasOwnProperty("funcName")||(s.calledFunctionsArguments[n]=[]);var r=[];s.calledFunctionsArguments[n].push(r),e.push(n),e.push("(");for(var a=0;a<t.arguments.length;++a){var i=t.arguments[a];if(a>0&&e.push(", "),this.astGeneric(i,e,s),"Identifier"===i.type){var u=s.paramNames.indexOf(i.name);-1===u?r.push(null):r.push({name:i.name,type:s.paramTypes[u]})}else r.push(null)}return e.push(")"),e}throw this.astErrorOutput("Unknown CallExpression",t,s)}},{key:"astArrayExpression",value:function(t,e,s){var n=t.elements.length;e.push("new Float32Array(");for(var r=0;r<n;++r){r>0&&e.push(", ");var a=t.elements[r];this.astGeneric(a,e,s)}return e.push(")"),e}},{key:"astDebuggerStatement",value:function(t,e,s){return e.push("debugger;"),e}}],[{key:"astFunctionPrototype",value:function(t,e,s){if(s.isRootKernel||s.isSubKernel)return e;e.push(s.returnType),e.push(" "),e.push(s.functionName),e.push("(");for(var n=0;n<s.paramNames.length;++n)n>0&&e.push(", "),e.push(s.paramTypes[n]),e.push(" "),e.push("user_"),e.push(s.paramNames[n]);return e.push(");\n"),e}}]),e}(BaseFunctionNode);
 
-},{"../../core/utils":74,"../function-node-base":56}],52:[function(require,module,exports){
+},{"../../core/utils":75,"../function-node-base":57}],53:[function(require,module,exports){
 "use strict";var utils=require("../../core/utils"),kernelRunShortcut=require("../kernel-run-shortcut");module.exports=function(n,t){return"() => {\n    "+kernelRunShortcut.toString()+";\n    const utils = {\n      allPropertiesOf: function "+utils.allPropertiesOf.toString()+",\n      clone: function "+utils.clone.toString()+",\n      /*splitArray: function "+utils.splitArray.toString()+",\n      getArgumentType: function "+utils.getArgumentType.toString()+",\n      getOutput: function "+utils.getOutput.toString()+",\n      dimToTexSize: function "+utils.dimToTexSize.toString()+",\n      copyFlatten: function "+utils.copyFlatten.toString()+",\n      flatten: function "+utils.flatten.toString()+",\n      systemEndianness: '"+utils.systemEndianness()+"',\n      initWebGl: function "+utils.initWebGl.toString()+",\n      isArray: function "+utils.isArray.toString()+"*/\n    };\n    class "+(t||"Kernel")+" {\n      constructor() {        \n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = "+JSON.stringify(n.paramNames)+";\n        this.paramTypes = "+JSON.stringify(n.paramTypes)+";\n        this.texSize = "+JSON.stringify(n.texSize)+";\n        this.output = "+JSON.stringify(n.output)+";\n        this._kernelString = `"+n._kernelString+"`;\n        this.output = "+JSON.stringify(n.output)+";\n\t\t    this.run = function() {\n          this.run = null;\n          this.build();\n          return this.run.apply(this, arguments);\n        }.bind(this);\n        this.thread = {\n          x: 0,\n          y: 0,\n          z: 0\n        };\n      }\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      "+n.build.toString()+"\n      run () { "+n.kernelString+" }\n      getKernelString() { return this._kernelString; }\n    };\n    return kernelRunShortcut(new Kernel());\n  };"};
 
-},{"../../core/utils":74,"../kernel-run-shortcut":58}],53:[function(require,module,exports){
+},{"../../core/utils":75,"../kernel-run-shortcut":59}],54:[function(require,module,exports){
 "use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}function _inherits(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}var _createClass=function(){function t(t,e){for(var n=0;n<e.length;n++){var r=e[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(e,n,r){return n&&t(e.prototype,n),r&&t(e,r),e}}(),KernelBase=require("../kernel-base"),utils=require("../../core/utils"),kernelString=require("./kernel-string");module.exports=function(t){function e(t,n){_classCallCheck(this,e);var r=_possibleConstructorReturn(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t,n));return r._fnBody=utils.getFunctionBodyFromString(t),r._fn=null,r.run=null,r._canvasCtx=null,r._imageData=null,r._colorData=null,r._kernelString=null,r.thread={x:0,y:0,z:0},r.run=function(){return this.run=null,this.build.apply(this,arguments),this.run.apply(this,arguments)}.bind(r),r}return _inherits(e,t),_createClass(e,[{key:"validateOptions",value:function(){if(!this.output||0===this.output.length){if(1!==arguments.length)throw"Auto dimensions only supported for kernels with only one input";var t=utils.getArgumentType(arguments[0]);if("Array"===t)this.output=utils.getDimensions(t);else{if("Texture"!==t)throw"Auto dimensions not supported for input type: "+t;this.output=arguments[0].output}}}},{key:"build",value:function(){this.setupParams(arguments);for(var t=this.threadDim=utils.clone(this.output);t.length<3;)t.push(1);if(this.graphical){var e=this.getCanvas();e.width=t[0],e.height=t[1],this._canvasCtx=e.getContext("2d"),this._imageData=this._canvasCtx.createImageData(t[0],t[1]),this._colorData=new Uint8ClampedArray(t[0]*t[1]*4)}var n=this.getKernelString();this.debug&&(console.log("Options:"),console.dir(this),console.log("Function output:"),console.log(n)),this.kernelString=n,this.run=new Function([],n).bind(this)()}},{key:"color",value:function(t,e,n,r){void 0===r&&(r=1),t=Math.floor(255*t),e=Math.floor(255*e),n=Math.floor(255*n),r=Math.floor(255*r);var i=this.output[0],s=this.output[1],u=this.thread.x,a=s-this.thread.y-1,l=u+a*i;this._colorData[4*l+0]=t,this._colorData[4*l+1]=e,this._colorData[4*l+2]=n,this._colorData[4*l+3]=r}},{key:"getKernelString",value:function(){var t=this;if(null!==this._kernelString)return this._kernelString;for(var e=this.functionBuilder,n=this.threadDim||(this.threadDim=utils.clone(this.output));n.length<3;)n.push(1);if(e.addKernel(this.fnString,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations},this.paramNames,this.paramTypes),e.addFunctions(this.functions,{constants:this.constants,output:this.output}),null!==this.subKernels){this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[];for(var r=0;r<this.subKernels.length;r++){var i=this.subKernels[r];e.addSubKernel(i,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations}),this.subKernelOutputVariableNames.push(i.name+"Result")}}else if(null!==this.subKernelProperties){this.subKernelOutputVariableNames=[];var s=0;for(var u in this.subKernelProperties)if(this.subKernelProperties.hasOwnProperty(u)){var a=this.subKernelProperties[u];e.addSubKernel(a),this.subKernelOutputVariableNames.push(a.name+"Result"),s++}}var l=e.getPrototypes(),o=l.shift();return this._kernelString="\n\t\tvar LOOP_MAX = "+this._getLoopMaxString()+";\n\t\tvar _this = this;\n  "+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"  var "+t+" = null;\n"}).join(""))+"\n    return function ("+this.paramNames.map(function(t){return"user_"+t}).join(", ")+") {\n    var ret = new Array("+n[2]+");\n  "+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"  "+t+"Z = new Array("+n[2]+");\n"}).join(""))+"\n    for (this.thread.z = 0; this.thread.z < "+n[2]+"; this.thread.z++) {\n      ret[this.thread.z] = new Array("+n[1]+");\n  "+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"    "+t+"Z[this.thread.z] = new Array("+n[1]+");\n"}).join(""))+"\n      for (this.thread.y = 0; this.thread.y < "+n[1]+"; this.thread.y++) {\n        ret[this.thread.z][this.thread.y] = new Array("+n[0]+");\n  "+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"      "+t+"Z[this.thread.z][this.thread.y] = new Array("+n[0]+");\n"}).join(""))+"\n        for (this.thread.x = 0; this.thread.x < "+n[0]+"; this.thread.x++) {\n          var kernelResult;\n          "+o+"\n          ret[this.thread.z][this.thread.y][this.thread.x] = kernelResult;\n"+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"        "+t+"Z[this.thread.z][this.thread.y][this.thread.x] = "+t+";\n"}).join(""))+"\n          }\n        }\n      }\n      \n      if (this.graphical) {\n        this._imageData.data.set(this._colorData);\n        this._canvasCtx.putImageData(this._imageData, 0, 0);\n        return;\n      }\n      \n      if (this.output.length === 1) {\n        ret = ret[0][0];\n"+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"    "+t+" = "+t+"Z[0][0];\n"}).join(""))+"\n      \n    } else if (this.output.length === 2) {\n      ret = ret[0];\n      "+(null===this.subKernelOutputVariableNames?"":this.subKernelOutputVariableNames.map(function(t){return"    "+t+" = "+t+"Z[0];\n"}).join(""))+"\n    }\n    \n    "+(null===this.subKernelOutputVariableNames?"return ret;\n":null!==this.subKernels?"var result = [\n        "+this.subKernelOutputVariableNames.map(function(t){return""+t}).join(",\n")+"\n      ];\n      result.result = ret;\n      return result;\n":"return {\n        result: ret,\n        "+Object.keys(this.subKernelProperties).map(function(e,n){return e+": "+t.subKernelOutputVariableNames[n]}).join(",\n")+"\n      };")+"\n    "+(l.length>0?l.join("\n"):"")+"\n    }.bind(this);"}},{key:"toString",value:function(){return kernelString(this)}},{key:"precompileKernelObj",value:function(t){return{threadDim:this.threadDim||(this.threadDim=utils.clone(this.output))}}},{key:"_getLoopMaxString",value:function(){return this.loopMaxIterations?" "+parseInt(this.loopMaxIterations)+";\n":" 1000;\n"}}],[{key:"compileKernel",value:function(t){for(var e=t.threadDim;e.length<3;)e.push(1)}}]),e}(KernelBase);
 
-},{"../../core/utils":74,"../kernel-base":57,"./kernel-string":52}],54:[function(require,module,exports){
+},{"../../core/utils":75,"../kernel-base":58,"./kernel-string":53}],55:[function(require,module,exports){
 "use strict";function _classCallCheck(e,r){if(!(e instanceof r))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,r){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!r||"object"!=typeof r&&"function"!=typeof r?e:r}function _inherits(e,r){if("function"!=typeof r&&null!==r)throw new TypeError("Super expression must either be null or a function, not "+typeof r);e.prototype=Object.create(r&&r.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),r&&(Object.setPrototypeOf?Object.setPrototypeOf(e,r):e.__proto__=r)}var _createClass=function(){function e(e,r){for(var t=0;t<r.length;t++){var n=r[t];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(r,t,n){return t&&e(r.prototype,t),n&&e(r,n),r}}(),utils=require("../../core/utils"),RunnerBase=require("../runner-base"),CPUKernel=require("./kernel"),CPUFunctionBuilder=require("./function-builder");module.exports=function(e){function r(e){_classCallCheck(this,r);var t=_possibleConstructorReturn(this,(r.__proto__||Object.getPrototypeOf(r)).call(this,new CPUFunctionBuilder,e));return t.Kernel=CPUKernel,t.kernel=null,t}return _inherits(r,e),_createClass(r,[{key:"getMode",value:function(){return"cpu"}}]),r}(RunnerBase);
 
-},{"../../core/utils":74,"../runner-base":59,"./function-builder":50,"./kernel":53}],55:[function(require,module,exports){
+},{"../../core/utils":75,"../runner-base":60,"./function-builder":51,"./kernel":54}],56:[function(require,module,exports){
 "use strict";function _classCallCheck(n,t){if(!(n instanceof t))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function n(n,t){for(var e=0;e<t.length;e++){var i=t[e];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(n,i.key,i)}}return function(t,e,i){return e&&n(t.prototype,e),i&&n(t,i),t}}();module.exports=function(){function n(t){_classCallCheck(this,n),this.nodeMap={},this.nativeFunctions={},this.gpu=t,this.rootKernel=null,this.Node=null}return _createClass(n,[{key:"addNativeFunction",value:function(n,t){this.nativeFunctions[n]=t}},{key:"addFunction",value:function(n,t,e,i,o){this.addFunctionNode(new this.Node(n,t,e,i,o).setAddFunction(this.addFunction.bind(this)))}},{key:"addFunctions",value:function(n,t){if(n)if(Array.isArray(n))for(var e=0;e<n.length;e++)this.addFunction(null,n[e],t);else for(var i in n)this.addFunction(i,n[i],t)}},{key:"addNativeFunctions",value:function(n){for(var t in n)n.hasOwnProperty(t)&&this.addNativeFunction(t,n[t])}},{key:"addFunctionNode",value:function(n){this.nodeMap[n.functionName]=n,n.isRootKernel&&(this.rootKernel=n)}},{key:"traceFunctionCalls",value:function(n,t,e){n=n||"kernel",t=t||[];var i=this.nodeMap[n];if(i){var o=t.indexOf(n);if(-1===o){t.push(n),e&&(i.parent=e),i.getFunctionString();for(var r=0;r<i.calledFunctions.length;++r)this.traceFunctionCalls(i.calledFunctions[r],t,i)}else{var a=t.splice(o,1)[0];t.push(a)}}return this.nativeFunctions[n]&&(t.indexOf(n)>=0||t.push(n)),t}},{key:"addKernel",value:function(n,t,e,i){var o=new this.Node("kernel",n,t,i);return o.setAddFunction(this.addFunction.bind(this)),o.paramNames=e,o.paramTypes=i,o.isRootKernel=!0,this.addFunctionNode(o),o}},{key:"addSubKernel",value:function(n,t,e,i){var o=new this.Node(null,n,t,e,i);return o.setAddFunction(this.addFunction.bind(this)),o.isSubKernel=!0,this.addFunctionNode(o),o}},{key:"getPrototypeString",value:function(n){return this.getPrototypes(n).join("\n")}},{key:"getPrototypes",value:function(n){return this.rootKernel.generate(),n?this.getPrototypesFromFunctionNames(this.traceFunctionCalls(n,[]).reverse()):this.getPrototypesFromFunctionNames(Object.keys(this.nodeMap))}},{key:"getStringFromFunctionNames",value:function(n){for(var t=[],e=0;e<n.length;++e){this.nodeMap[n[e]]&&t.push(this.nodeMap[n[e]].getFunctionString())}return t.join("\n")}},{key:"getPrototypesFromFunctionNames",value:function(n,t){for(var e=[],i=0;i<n.length;++i){var o=n[i],r=this.nodeMap[o];r?e.push(r.getFunctionPrototypeString(t)):this.nativeFunctions[o]&&e.push(this.nativeFunctions[o])}return e}},{key:"getPrototypeStringFromFunctionNames",value:function(n,t){return this.getPrototypesFromFunctionNames(n,t).toString()}},{key:"getString",value:function(n,t){return void 0===t&&(t={}),n?this.getStringFromFunctionNames(this.traceFunctionCalls(n,[],t).reverse(),t):this.getStringFromFunctionNames(Object.keys(this.nodeMap),t)}},{key:"polyfillStandardFunctions",value:function(){throw new Error("polyfillStandardFunctions not defined on base function builder")}}]),n}();
 
-},{}],56:[function(require,module,exports){
+},{}],57:[function(require,module,exports){
 "use strict";function _classCallCheck(t,n){if(!(t instanceof n))throw new TypeError("Cannot call a class as a function")}var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},_createClass=function(){function t(t,n){for(var e=0;e<n.length;e++){var r=n[e];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(n,e,r){return e&&t(n.prototype,e),r&&t(n,r),n}}(),utils=require("../core/utils"),acorn=require("acorn");module.exports=function(){function BaseFunctionNode(t,n,e,r,i){if(_classCallCheck(this,BaseFunctionNode),this.calledFunctions=[],this.calledFunctionsArguments={},this.initVariables=[],this.readVariables=[],this.writeVariables=[],this.addFunction=null,this.isRootKernel=!1,this.isSubKernel=!1,this.parent=null,this.debug=null,this.prototypeOnly=null,this.constants=null,this.output=null,e&&(e.hasOwnProperty("debug")&&(this.debug=e.debug),e.hasOwnProperty("prototypeOnly")&&(this.prototypeOnly=e.prototypeOnly),e.hasOwnProperty("constants")&&(this.constants=e.constants),e.hasOwnProperty("output")&&(this.output=e.output),e.hasOwnProperty("loopMaxIterations")&&(this.loopMaxIterations=e.loopMaxIterations)),!n)throw"jsFunction, parameter is missing";if(this.jsFunctionString=n.toString(),!utils.isFunctionString(this.jsFunctionString))throw console.error("jsFunction, to string conversion check failed: not a function?",this.jsFunctionString),"jsFunction, to string conversion check failed: not a function?";if(utils.isFunction(n)?this.jsFunction=n:this.jsFunction=null,this.functionName=t||n&&n.name||utils.getFunctionNameFromString(this.jsFunctionString),!this.functionName)throw"jsFunction, missing name argument or value";if(this.paramNames=utils.getParamNamesFromString(this.jsFunctionString),r){if(Array.isArray(r)){if(r.length!==this.paramNames.length)throw"Invalid argument type array length, against function length -> ("+r.length+","+this.paramNames.length+")";this.paramTypes=r}else if("object"===(void 0===r?"undefined":_typeof(r))){var s=Object.keys(r);if(r.hasOwnProperty("returns")&&(this.returnType=r.returns,s.splice(s.indexOf("returns"),1)),s.length>0&&s.length!==this.paramNames.length)throw"Invalid argument type array length, against function length -> ("+s.length+","+this.paramNames.length+")";this.paramTypes=this.paramNames.map(function(t){return r.hasOwnProperty(t)?r[t]:"float"})}}else this.paramTypes=[];this.returnType||(this.returnType=i||"float")}return _createClass(BaseFunctionNode,[{key:"isIdentifierConstant",value:function(t){return!!this.constants&&this.constants.hasOwnProperty(t)}},{key:"setAddFunction",value:function(t){return this.addFunction=t,this}},{key:"getJsFunction",value:function getJsFunction(){if(this.jsFunction)return this.jsFunction;if(this.jsFunctionString)return this.jsFunction=eval(this.jsFunctionString),this.jsFunction;throw"Missing jsFunction, and jsFunctionString parameter"}},{key:"astMemberExpressionUnroll",value:function(t,n){if("Identifier"===t.type)return t.name;if("ThisExpression"===t.type)return"this";if("MemberExpression"===t.type&&t.object&&t.property)return t.object.hasOwnProperty("name")&&"_"===t.object.name[0]?this.astMemberExpressionUnroll(t.property,n):this.astMemberExpressionUnroll(t.object,n)+"."+this.astMemberExpressionUnroll(t.property,n);if(t.hasOwnProperty("expressions")){var e=t.expressions[0];if("Literal"===e.type&&0===e.value&&2===t.expressions.length)return this.astMemberExpressionUnroll(t.expressions[1])}throw this.astErrorOutput("Unknown CallExpression_unroll",t,n)}},{key:"getJsAST",value:function(t){if(this.jsFunctionAST)return this.jsFunctionAST;if(null===(t=t||acorn))throw"Missing JS to AST parser";var n=t.parse("var "+this.functionName+" = "+this.jsFunctionString+";",{locations:!0});if(null===n)throw"Failed to parse JS code";var e=n.body[0].declarations[0].init;return this.jsFunctionAST=e,e}},{key:"getFunctionString",value:function(){return this.generate(),this.functionString}},{key:"setFunctionString",value:function(t){this.functionString=t}},{key:"getParamType",value:function(t){var n=this.paramNames.indexOf(t);if(-1===n)return null;if(!this.parent)return null;if(this.paramTypes[n])return this.paramTypes[n];for(var e=this.parent.calledFunctionsArguments[this.functionName],r=0;r<e.length;r++){var i=e[r];if(null!==i[n])return this.paramTypes[n]=i[n].type}return null}},{key:"getUserParamName",value:function(t){var n=this.paramNames.indexOf(t);if(-1===n)return null;if(!this.parent)return null;for(var e=this.parent.calledFunctionsArguments[this.functionName],r=0;r<e.length;r++){var i=e[r];if(null!==i[n])return i[n].name}return null}},{key:"generate",value:function(t){throw new Error("generate not defined on BaseFunctionNode")}},{key:"astErrorOutput",value:function(t,n,e){return console.error(utils.getAstString(this.jsFunctionString,n)),console.error(t,n,e),t}},{key:"astDebuggerStatement",value:function(t,n,e){return n}}]),BaseFunctionNode}();
 
-},{"../core/utils":74,"acorn":76}],57:[function(require,module,exports){
+},{"../core/utils":75,"acorn":45}],58:[function(require,module,exports){
 "use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function t(t,e){for(var n=0;n<e.length;n++){var u=e[n];u.enumerable=u.enumerable||!1,u.configurable=!0,"value"in u&&(u.writable=!0),Object.defineProperty(t,u.key,u)}}return function(e,n,u){return n&&t(e.prototype,n),u&&t(e,u),e}}(),utils=require("../core/utils");module.exports=function(){function t(e,n){_classCallCheck(this,t),this.paramNames=utils.getParamNamesFromString(e),this.fnString=e,this.output=null,this.debug=!1,this.graphical=!1,this.loopMaxIterations=0,this.constants=null,this.wraparound=null,this.hardcodeConstants=null,this.outputToTexture=null,this.texSize=null,this._canvas=null,this._webGl=null,this.threadDim=null,this.floatTextures=null,this.floatOutput=null,this.floatOutputForce=null,this.addFunction=null,this.functions=null,this.nativeFunctions=null,this.copyData=!0,this.subKernels=null,this.subKernelProperties=null,this.subKernelNames=null,this.subKernelOutputVariableNames=null,this.functionBuilder=null,this.paramTypes=null;for(var u in n)n.hasOwnProperty(u)&&this.hasOwnProperty(u)&&(this[u]=n[u]);n.hasOwnProperty("canvas")&&(this._canvas=n.canvas),n.hasOwnProperty("output")&&this.setOutput(n.output),this._canvas||(this._canvas=utils.initCanvas())}return _createClass(t,[{key:"build",value:function(){throw new Error('"build" not defined on Base')}},{key:"setupParams",value:function(t){for(var e=this.paramTypes=[],n=0;n<t.length;n++){var u=t[n],s=utils.getArgumentType(u);e.push(s)}}},{key:"setAddFunction",value:function(t){return this.addFunction=t,this}},{key:"setFunctions",value:function(t){return this.functions=t,this}},{key:"setOutput",value:function(t){return t.hasOwnProperty("x")?t.hasOwnProperty("y")?t.hasOwnProperty("z")?this.output=[t.x,t.y,t.z]:this.output=[t.x,t.y]:this.output=[t.x]:this.output=t,this}},{key:"setDebug",value:function(t){return this.debug=t,this}},{key:"setGraphical",value:function(t){return this.graphical=t,this}},{key:"setLoopMaxIterations",value:function(t){return this.loopMaxIterations=t,this}},{key:"setConstants",value:function(t){return this.constants=t,this}},{key:"setWraparound",value:function(t){return console.warn("Wraparound mode is not supported and undocumented."),this.wraparound=t,this}},{key:"setHardcodeConstants",value:function(t){return this.hardcodeConstants=t,this}},{key:"setOutputToTexture",value:function(t){return this.outputToTexture=t,this}},{key:"setFloatTextures",value:function(t){return this.floatTextures=t,this}},{key:"setFloatOutput",value:function(t){return this.floatOutput=t,this}},{key:"setFloatOutputForce",value:function(t){return this.floatOutputForce=t,this}},{key:"setCanvas",value:function(t){return this._canvas=t,this}},{key:"setWebGl",value:function(t){return this._webGl=t,this}},{key:"setCopyData",value:function(t){return this.copyData=t,this}},{key:"getCanvas",value:function(){return this._canvas}},{key:"getWebGl",value:function(){return this._webGl}},{key:"validateOptions",value:function(){throw new Error("validateOptions not defined")}},{key:"exec",value:function(){return this.execute.apply(this,arguments)}},{key:"execute",value:function(){var t=this,e=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);return utils.newPromise(function(n,u){try{n(t.run.apply(t,e))}catch(t){u(t)}})}},{key:"addSubKernel",value:function(t){return null===this.subKernels&&(this.subKernels=[],this.subKernelNames=[]),this.subKernels.push(t),this.subKernelNames.push(utils.getFunctionNameFromString(t)),this}},{key:"addSubKernelProperty",value:function(t,e){if(null===this.subKernelProperties&&(this.subKernelProperties={},this.subKernelNames=[]),this.subKernelProperties.hasOwnProperty(t))throw new Error("cannot add sub kernel "+t+", already defined");return this.subKernelProperties[t]=e,this.subKernelNames.push(utils.getFunctionNameFromString(e)),this}},{key:"addNativeFunction",value:function(t,e){this.functionBuilder.addNativeFunction(t,e)}}]),t}();
 
-},{"../core/utils":74}],58:[function(require,module,exports){
+},{"../core/utils":75}],59:[function(require,module,exports){
 "use strict";var utils=require("../core/utils");module.exports=function(t){var n=function(){return t.run.apply(t,arguments)};return utils.allPropertiesOf(t).forEach(function(e){"_"===e[0]&&"_"===e[1]||("function"==typeof t[e]?n[e]="add"===e.substring(0,3)||"set"===e.substring(0,3)?function(){return t[e].apply(t,arguments),n}:t[e].bind(t):(n.__defineGetter__(e,function(){return t[e]}),n.__defineSetter__(e,function(n){t[e]=n})))}),n.kernel=t,n};
 
-},{"../core/utils":74}],59:[function(require,module,exports){
+},{"../core/utils":75}],60:[function(require,module,exports){
 "use strict";function _classCallCheck(e,n){if(!(e instanceof n))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(n,t,r){return t&&e(n.prototype,t),r&&e(n,r),n}}(),utils=require("../core/utils"),kernelRunShortcut=require("./kernel-run-shortcut");module.exports=function(){function e(n,t){_classCallCheck(this,e),t=t||{},this.kernel=t.kernel,this.canvas=t.canvas,this.webGl=t.webGl,this.fn=null,this.functionBuilder=n,this.fnString=null,this.endianness=utils.systemEndianness(),this.functionBuilder.polyfillStandardFunctions()}return _createClass(e,[{key:"textureToArray",value:function(e){return this.createKernel(function(e){return e[this.thread.z][this.thread.y][this.thread.x]})(e)}},{key:"deleteTexture",value:function(e){this.webGl.deleteTexture(e.texture)}},{key:"buildPromiseKernel",value:function(){throw new Error("not yet implemented")}},{key:"getMode",value:function(){throw new Error('"mode" not implemented on BaseRunner')}},{key:"buildKernel",value:function(e,n){n=Object.assign({},n||{});var t=e.toString();return n.functionBuilder||(n.functionBuilder=this.functionBuilder),n.canvas||(n.canvas=this.canvas),n.webGl||(n.webGl=this.webgl),kernelRunShortcut(new this.Kernel(t,n))}}]),e}();
 
-},{"../core/utils":74,"./kernel-run-shortcut":58}],60:[function(require,module,exports){
+},{"../core/utils":75,"./kernel-run-shortcut":59}],61:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function _round(e){return Math.floor(e+.5)}var _createClass=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),FunctionBuilderBase=require("../function-builder-base"),WebGLFunctionNode=require("./function-node");module.exports=function(e){function t(){_classCallCheck(this,t);var e=_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).call(this));return e.Node=WebGLFunctionNode,e}return _inherits(t,e),_createClass(t,[{key:"polyfillStandardFunctions",value:function(){this.addFunction("round",_round)}}],[{key:"round",value:function(e){return _round(e)}}]),t}(FunctionBuilderBase);
 
-},{"../function-builder-base":55,"./function-node":61}],61:[function(require,module,exports){
+},{"../function-builder-base":56,"./function-node":62}],62:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function isIdentifierKernelParam(e,t,s){return-1!==s.paramNames.indexOf(e)}function ensureIndentifierType(e,t,s,r){var n=s.loc.start;if(!isIdentifierKernelParam(e,r)&&"float"!==t)throw new Error("Error unexpected identifier "+e+" on line "+n.line);if(r.paramTypes[r.paramNames.indexOf(e)]!==t)throw new Error("Error unexpected identifier "+e+" on line "+n.line)}function webGlRegexOptimize(e){return e.replace(DECODE32_ENCODE32,"((").replace(ENCODE32_DECODE32,"((")}var _createClass=function(){function e(e,t){for(var s=0;s<t.length;s++){var r=t[s];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,s,r){return s&&e(t.prototype,s),r&&e(t,r),t}}(),FunctionNodeBase=require("../function-node-base"),utils=require("../../core/utils"),jsMathPrefix="Math.",localPrefix="this.",constantsPrefix="this.constants.",DECODE32_ENCODE32=/decode32\(\s+encode32\(/g,ENCODE32_DECODE32=/encode32\(\s+decode32\(/g;module.exports=function(e){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return _inherits(t,e),_createClass(t,[{key:"generate",value:function(){return this.debug&&console.log(this),this.prototypeOnly?t.astFunctionPrototype(this.getJsAST(),[],this).join("").trim():(this.functionStringArray=this.astGeneric(this.getJsAST(),[],this),this.functionString=webGlRegexOptimize(this.functionStringArray.join("").trim()),this.functionString)}},{key:"astGeneric",value:function(e,t,s){if(null===e)throw this.astErrorOutput("NULL ast",e,s);if(Array.isArray(e)){for(var r=0;r<e.length;r++)this.astGeneric(e[r],t,s);return t}switch(e.type){case"FunctionDeclaration":return this.astFunctionDeclaration(e,t,s);case"FunctionExpression":return this.astFunctionExpression(e,t,s);case"ReturnStatement":return this.astReturnStatement(e,t,s);case"Literal":return this.astLiteral(e,t,s);case"BinaryExpression":return this.astBinaryExpression(e,t,s);case"Identifier":return this.astIdentifierExpression(e,t,s);case"AssignmentExpression":return this.astAssignmentExpression(e,t,s);case"ExpressionStatement":return this.astExpressionStatement(e,t,s);case"EmptyStatement":return this.astEmptyStatement(e,t,s);case"BlockStatement":return this.astBlockStatement(e,t,s);case"IfStatement":return this.astIfStatement(e,t,s);case"BreakStatement":return this.astBreakStatement(e,t,s);case"ContinueStatement":return this.astContinueStatement(e,t,s);case"ForStatement":return this.astForStatement(e,t,s);case"WhileStatement":return this.astWhileStatement(e,t,s);case"VariableDeclaration":return this.astVariableDeclaration(e,t,s);case"VariableDeclarator":return this.astVariableDeclarator(e,t,s);case"ThisExpression":return this.astThisExpression(e,t,s);case"SequenceExpression":return this.astSequenceExpression(e,t,s);case"UnaryExpression":return this.astUnaryExpression(e,t,s);case"UpdateExpression":return this.astUpdateExpression(e,t,s);case"LogicalExpression":return this.astLogicalExpression(e,t,s);case"MemberExpression":return this.astMemberExpression(e,t,s);case"CallExpression":return this.astCallExpression(e,t,s);case"ArrayExpression":return this.astArrayExpression(e,t,s);case"DebuggerStatement":return this.astDebuggerStatement(e,t,s)}throw this.astErrorOutput("Unknown ast type : "+e.type,e,s)}},{key:"astFunctionDeclaration",value:function(e,t,s){return this.addFunction&&this.addFunction(null,utils.getAstString(this.jsFunctionString,e)),t}},{key:"astFunctionExpression",value:function(e,t,s){if(s.isRootKernel?(t.push("void"),s.kernalAst=e):t.push(s.returnType),t.push(" "),t.push(s.functionName),t.push("("),!s.isRootKernel)for(var r=0;r<s.paramNames.length;++r){var n=s.paramNames[r];r>0&&t.push(", ");var i=s.getParamType(n);switch(i){case"Texture":case"Input":case"Array":t.push("sampler2D");break;default:t.push("float")}t.push(" "),t.push("user_"),t.push(n)}t.push(") {\n");for(var a=0;a<e.body.body.length;++a)this.astGeneric(e.body.body[a],t,s),t.push("\n");return t.push("}\n"),t}},{key:"astReturnStatement",value:function(e,t,s){return s.isRootKernel?(t.push("kernelResult = "),this.astGeneric(e.argument,t,s),t.push(";"),t.push("return;")):s.isSubKernel?(t.push(s.functionName+"Result = "),this.astGeneric(e.argument,t,s),t.push(";"),t.push("return "+s.functionName+"Result;")):(t.push("return "),this.astGeneric(e.argument,t,s),t.push(";")),t}},{key:"astLiteral",value:function(e,t,s){if(isNaN(e.value))throw this.astErrorOutput("Non-numeric literal not supported : "+e.value,e,s);return t.push(e.value),Number.isInteger(e.value)&&t.push(".0"),t}},{key:"astBinaryExpression",value:function(e,t,s){return t.push("("),"%"===e.operator?(t.push("mod("),this.astGeneric(e.left,t,s),t.push(","),this.astGeneric(e.right,t,s),t.push(")")):"==="===e.operator?(this.astGeneric(e.left,t,s),t.push("=="),this.astGeneric(e.right,t,s)):"!=="===e.operator?(this.astGeneric(e.left,t,s),t.push("!="),this.astGeneric(e.right,t,s)):(this.astGeneric(e.left,t,s),t.push(e.operator),this.astGeneric(e.right,t,s)),t.push(")"),t}},{key:"astIdentifierExpression",value:function(e,t,s){if("Identifier"!==e.type)throw this.astErrorOutput("IdentifierExpression - not an Identifier",e,s);switch(e.name){case"gpu_threadX":t.push("threadId.x");break;case"gpu_threadY":t.push("threadId.y");break;case"gpu_threadZ":t.push("threadId.z");break;case"gpu_outputX":t.push("uOutputDim.x");break;case"gpu_outputY":t.push("uOutputDim.y");break;case"gpu_outputZ":t.push("uOutputDim.z");break;default:if(this.constants&&this.constants.hasOwnProperty(e.name))t.push("constants_"+e.name);else{var r=s.getUserParamName(e.name);null!==r?t.push("user_"+r):t.push("user_"+e.name)}}return t}},{key:"astForStatement",value:function(e,t,s){if("ForStatement"!==e.type)throw this.astErrorOutput("Invalid for statment",e,s);if(e.test&&"BinaryExpression"===e.test.type){if("Identifier"===e.test.right.type&&"<"===e.test.operator&&!1===this.isIdentifierConstant(e.test.right.name)){if(this.loopMaxIterations||(console.warn("Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior."),console.warn("Set loopMaxIterations or use a for loop of fixed length to silence this message.")),t.push("for ("),this.astGeneric(e.init,t,s),this.astGeneric(e.test.left,t,s),t.push(e.test.operator),t.push("LOOP_MAX"),t.push(";"),this.astGeneric(e.update,t,s),t.push(")"),t.push("{\n"),t.push("if ("),this.astGeneric(e.test.left,t,s),t.push(e.test.operator),this.astGeneric(e.test.right,t,s),t.push(") {\n"),"BlockStatement"===e.body.type)for(var r=0;r<e.body.body.length;r++)this.astGeneric(e.body.body[r],t,s);else this.astGeneric(e.body,t,s);return t.push("} else {\n"),t.push("break;\n"),t.push("}\n"),t.push("}\n"),t}var n=JSON.parse(JSON.stringify(e.init.declarations)),i=e.update.argument;if(!Array.isArray(n)||n.length<1)throw console.log(this.jsFunctionString),new Error("Error: Incompatible for loop declaration");if(n.length>1){for(var a=null,u=0;u<n.length;u++){var o=n[u];o.id.name===i.name?(a=o,n.splice(u,1)):(t.push("float "),this.astGeneric(o,t,s),t.push(";"))}t.push("for (float "),this.astGeneric(a,t,s),t.push(";")}else t.push("for ("),this.astGeneric(e.init,t,s);return this.astGeneric(e.test,t,s),t.push(";"),this.astGeneric(e.update,t,s),t.push(")"),this.astGeneric(e.body,t,s),t}throw this.astErrorOutput("Invalid for statement",e,s)}},{key:"astWhileStatement",value:function(e,t,s){if("WhileStatement"!==e.type)throw this.astErrorOutput("Invalid while statment",e,s);return t.push("for (float i = 0.0; i < LOOP_MAX; i++) {"),t.push("if ("),this.astGeneric(e.test,t,s),t.push(") {\n"),this.astGeneric(e.body,t,s),t.push("} else {\n"),t.push("break;\n"),t.push("}\n"),t.push("}\n"),t}},{key:"astAssignmentExpression",value:function(e,t,s){if("%="!==e.operator)return this.astGeneric(e.left,t,s),t.push(e.operator),this.astGeneric(e.right,t,s),t;this.astGeneric(e.left,t,s),t.push("="),t.push("mod("),this.astGeneric(e.left,t,s),t.push(","),this.astGeneric(e.right,t,s),t.push(")")}},{key:"astEmptyStatement",value:function(e,t,s){return t}},{key:"astBlockStatement",value:function(e,t,s){t.push("{\n");for(var r=0;r<e.body.length;r++)this.astGeneric(e.body[r],t,s);return t.push("}\n"),t}},{key:"astExpressionStatement",value:function(e,t,s){return this.astGeneric(e.expression,t,s),t.push(";\n"),t}},{key:"astVariableDeclaration",value:function(e,t,s){t.push("float ");for(var r=0;r<e.declarations.length;r++)r>0&&t.push(","),this.astGeneric(e.declarations[r],t,s);return t.push(";"),t}},{key:"astVariableDeclarator",value:function(e,t,s){return this.astGeneric(e.id,t,s),null!==e.init&&(t.push("="),this.astGeneric(e.init,t,s)),t}},{key:"astIfStatement",value:function(e,t,s){return t.push("if ("),this.astGeneric(e.test,t,s),t.push(")"),"BlockStatement"===e.consequent.type?this.astGeneric(e.consequent,t,s):(t.push(" {\n"),this.astGeneric(e.consequent,t,s),t.push("\n}\n")),e.alternate&&(t.push("else "),"BlockStatement"===e.alternate.type?this.astGeneric(e.alternate,t,s):(t.push(" {\n"),this.astGeneric(e.alternate,t,s),t.push("\n}\n"))),t}},{key:"astBreakStatement",value:function(e,t,s){return t.push("break;\n"),t}},{key:"astContinueStatement",value:function(e,t,s){return t.push("continue;\n"),t}},{key:"astLogicalExpression",value:function(e,t,s){return t.push("("),this.astGeneric(e.left,t,s),t.push(e.operator),this.astGeneric(e.right,t,s),t.push(")"),t}},{key:"astUpdateExpression",value:function(e,t,s){return e.prefix?(t.push(e.operator),this.astGeneric(e.argument,t,s)):(this.astGeneric(e.argument,t,s),t.push(e.operator)),t}},{key:"astUnaryExpression",value:function(e,t,s){return e.prefix?(t.push(e.operator),this.astGeneric(e.argument,t,s)):(this.astGeneric(e.argument,t,s),t.push(e.operator)),t}},{key:"astThisExpression",value:function(e,t,s){return t.push("this"),t}},{key:"astMemberExpression",value:function(e,t,s){if(e.computed)if("Identifier"===e.object.type){var r=e.object.name,n=(s.functionName,!1);if(s.paramNames){var i=s.paramNames.indexOf(r);i>=0&&"float"===s.paramTypes[i]&&(n=!0)}n?(this.astGeneric(e.object,t,s),t.push("[int("),this.astGeneric(e.property,t,s),t.push(")]")):(t.push("get("),this.astGeneric(e.object,t,s),t.push(", vec2("),this.astGeneric(e.object,t,s),t.push("Size[0],"),this.astGeneric(e.object,t,s),t.push("Size[1]), vec3("),this.astGeneric(e.object,t,s),t.push("Dim[0],"),this.astGeneric(e.object,t,s),t.push("Dim[1],"),this.astGeneric(e.object,t,s),t.push("Dim[2]"),t.push("), "),this.astGeneric(e.property,t,s),t.push(")"))}else{this.astGeneric(e.object,t,s);var a=t.pop();t.push(","),this.astGeneric(e.property,t,s),t.push(a)}else{var u=this.astMemberExpressionUnroll(e),o=u.toLowerCase();switch(0===u.indexOf(constantsPrefix)&&(u="constants_"+u.slice(constantsPrefix.length)),o){case"this.thread.x":t.push("threadId.x");break;case"this.thread.y":t.push("threadId.y");break;case"this.thread.z":t.push("threadId.z");break;case"this.output.x":t.push(this.output[0]+".0");break;case"this.output.y":t.push(this.output[1]+".0");break;case"this.output.z":t.push(this.output[2]+".0");break;default:t.push(u)}}return t}},{key:"astSequenceExpression",value:function(e,t,s){for(var r=0;r<e.expressions.length;r++)r>0&&t.push(","),this.astGeneric(e.expressions,t,s);return t}},{key:"astCallExpression",value:function(e,t,s){if(e.callee){var r=this.astMemberExpressionUnroll(e.callee);0===r.indexOf(jsMathPrefix)&&(r=r.slice(jsMathPrefix.length)),0===r.indexOf(localPrefix)&&(r=r.slice(localPrefix.length)),s.calledFunctions.indexOf(r)<0&&s.calledFunctions.push(r),s.hasOwnProperty("funcName")||(s.calledFunctionsArguments[r]=[]);var n=[];s.calledFunctionsArguments[r].push(n),t.push(r),t.push("(");for(var i=0;i<e.arguments.length;++i){var a=e.arguments[i];if(i>0&&t.push(", "),this.astGeneric(a,t,s),"Identifier"===a.type){var u=s.paramNames.indexOf(a.name);-1===u?n.push(null):n.push({name:a.name,type:s.paramTypes[u]})}else n.push(null)}return t.push(")"),t}throw this.astErrorOutput("Unknown CallExpression",e,s)}},{key:"astArrayExpression",value:function(e,t,s){var r=e.elements.length;t.push("float["+r+"](");for(var n=0;n<r;++n){n>0&&t.push(", ");var i=e.elements[n];this.astGeneric(i,t,s)}return t.push(")"),t}},{key:"getFunctionPrototypeString",value:function(){return this.webGlFunctionPrototypeString?this.webGlFunctionPrototypeString:this.webGlFunctionPrototypeString=this.generate()}},{key:"build",value:function(){return this.getFunctionPrototypeString().length>0}}],[{key:"astFunctionPrototype",value:function(e,t,s){if(s.isRootKernel||s.isSubKernel)return t;t.push(s.returnType),t.push(" "),t.push(s.functionName),t.push("(");for(var r=0;r<s.paramNames.length;++r)r>0&&t.push(", "),t.push(s.paramTypes[r]),t.push(" "),t.push("user_"),t.push(s.paramNames[r]);return t.push(");\n"),t}}]),t}(FunctionNodeBase);
 
-},{"../../core/utils":74,"../function-node-base":56}],62:[function(require,module,exports){
+},{"../../core/utils":75,"../function-node-base":57}],63:[function(require,module,exports){
 "use strict";var utils=require("../../core/utils"),kernelRunShortcut=require("../kernel-run-shortcut");module.exports=function(t,n){return"() => {\n    "+kernelRunShortcut.toString()+";\n    const utils = {\n      allPropertiesOf: function "+utils.allPropertiesOf.toString()+",\n      clone: function "+utils.clone.toString()+",\n      splitArray: function "+utils.splitArray.toString()+",\n      getArgumentType: function "+utils.getArgumentType.toString()+",\n      getDimensions: function "+utils.getDimensions.toString()+",\n      dimToTexSize: function "+utils.dimToTexSize.toString()+",\n      copyFlatten: function "+utils.copyFlatten.toString()+",\n      flatten: function "+utils.flatten.toString()+",\n      systemEndianness: '"+utils.systemEndianness()+"',\n      initWebGl: function "+utils.initWebGl.toString()+",\n      isArray: function "+utils.isArray.toString()+"\n    };\n    class "+(n||"Kernel")+" {\n      constructor() {\n        this.argumentsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.built = false;\n        this.program = null;\n        this.paramNames = "+JSON.stringify(t.paramNames)+";\n        this.paramTypes = "+JSON.stringify(t.paramTypes)+";\n        this.texSize = "+JSON.stringify(t.texSize)+";\n        this.output = "+JSON.stringify(t.output)+";\n        this.compiledFragShaderString = `"+t.compiledFragShaderString+"`;\n\t\t    this.compiledVertShaderString = `"+t.compiledVertShaderString+"`;\n\t\t    this.programUniformLocationCache = {};\n\t\t    this.textureCache = {};\n\t\t    this.subKernelOutputTextures = null;\n      }\n      "+t._getFragShaderString.toString()+"\n      "+t._getVertShaderString.toString()+"\n      validateOptions() {}\n      setupParams() {}\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      "+t.getUniformLocation.toString()+"\n      "+t.setupParams.toString()+"\n      "+t.build.toString()+"\n\t\t  "+t.run.toString()+"\n\t\t  "+t._addArgument.toString()+"\n\t\t  "+t.getArgumentTexture.toString()+"\n\t\t  "+t.getTextureCache.toString()+"\n\t\t  "+t.getOutputTexture.toString()+"\n\t\t  "+t.renderOutput.toString()+"\n    };\n    return kernelRunShortcut(new Kernel());\n  };"};
 
-},{"../../core/utils":74,"../kernel-run-shortcut":58}],63:[function(require,module,exports){
+},{"../../core/utils":75,"../kernel-run-shortcut":59}],64:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var _createClass=function(){function e(e,t){for(var r=0;r<t.length;r++){var i=t[r];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(e,i.key,i)}}return function(t,r,i){return r&&e(t.prototype,r),i&&e(t,i),t}}(),KernelBase=require("../kernel-base"),utils=require("../../core/utils"),Texture=require("../../core/texture"),fragShaderString=require("./shader-frag"),vertShaderString=require("./shader-vert"),kernelString=require("./kernel-string"),canvases=[],maxTexSizes={};module.exports=function(e){function t(e,r){_classCallCheck(this,t);var i=_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e,r));return i.textureCache={},i.threadDim={},i.programUniformLocationCache={},i.framebuffer=null,i.buffer=null,i.program=null,i.outputToTexture=r.outputToTexture,i.endianness=utils.systemEndianness(),i.subKernelOutputTextures=null,i.subKernelOutputVariableNames=null,i.argumentsLength=0,i.ext=null,i.compiledFragShaderString=null,i.compiledVertShaderString=null,i.extDrawBuffersMap=null,i.outputTexture=null,i.maxTexSize=null,i._webGl||(i._webGl=utils.initWebGl(i.getCanvas())),i}return _inherits(t,e),_createClass(t,[{key:"validateOptions",value:function(){var e=utils.isFloatReadPixelsSupported();if(!0===this.floatTextures&&!utils.OES_texture_float)throw new Error("Float textures are not supported on this browser");if(!0===this.floatOutput&&!0!==this.floatOutputForce&&!e)throw new Error("Float texture outputs are not supported on this browser");if(void 0===this.floatTextures&&utils.OES_texture_float&&(this.floatTextures=!0,this.floatOutput=e),!this.output||0===this.output.length){if(1!==arguments.length)throw new Error("Auto output only supported for kernels with only one input");var t=utils.getArgumentType(arguments[0]);if("Array"===t)this.output=utils.getDimensions(t);else{if("Texture"!==t)throw new Error("Auto output not supported for input type: "+t);this.output=arguments[0].output}}if(this.texSize=utils.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},this.output,!0),this.graphical){if(2!==this.output.length)throw new Error("Output must have 2 dimensions on graphical mode");this.floatOutput&&(this.floatOutput=!1,console.warn("Cannot use graphical mode and float output at the same time")),this.texSize=utils.clone(this.output)}else void 0===this.floatOutput&&utils.OES_texture_float&&(this.floatOutput=!0)}},{key:"updateMaxTexSize",value:function(){var e=this.texSize,t=this._canvas;if(null===this.maxTexSize){var r=canvases.indexOf(t);-1===r&&(r=canvases.length,canvases.push(t),maxTexSizes[r]=[e[0],e[1]]),this.maxTexSize=maxTexSizes[r]}this.maxTexSize[0]<e[0]&&(this.maxTexSize[0]=e[0]),this.maxTexSize[1]<e[1]&&(this.maxTexSize[1]=e[1])}},{key:"build",value:function(){this.validateOptions(),this.setupParams(arguments),this.updateMaxTexSize();var e=this.texSize,t=this._webGl,r=this._canvas;t.enable(t.SCISSOR_TEST),t.viewport(0,0,this.maxTexSize[0],this.maxTexSize[1]),r.width=this.maxTexSize[0],r.height=this.maxTexSize[1];for(var i=this.threadDim=utils.clone(this.output);i.length<3;)i.push(1);this.functionBuilder&&this._addKernels();var n=this._getVertShaderString(arguments),u=t.createShader(t.VERTEX_SHADER);t.shaderSource(u,n),t.compileShader(u);var s=this._getFragShaderString(arguments),a=t.createShader(t.FRAGMENT_SHADER);if(t.shaderSource(a,s),t.compileShader(a),!t.getShaderParameter(u,t.COMPILE_STATUS))throw console.log(n),console.error("An error occurred compiling the shaders: "+t.getShaderInfoLog(u)),new Error("Error compiling vertex shader");if(!t.getShaderParameter(a,t.COMPILE_STATUS))throw console.log(s),console.error("An error occurred compiling the shaders: "+t.getShaderInfoLog(a)),new Error("Error compiling fragment shader");this.debug&&(console.log("Options:"),console.dir(this),console.log("GLSL Shader Output:"),console.log(s));var o=this.program=t.createProgram();t.attachShader(o,u),t.attachShader(o,a),t.linkProgram(o),this.framebuffer=t.createFramebuffer(),this.framebuffer.width=e[0],this.framebuffer.height=e[1];var h=new Float32Array([-1,-1,1,-1,-1,1,1,1]),l=new Float32Array([0,0,1,0,0,1,1,1]),T=h.byteLength,f=this.buffer;f?t.bindBuffer(t.ARRAY_BUFFER,f):(f=this.buffer=t.createBuffer(),t.bindBuffer(t.ARRAY_BUFFER,f),t.bufferData(t.ARRAY_BUFFER,h.byteLength+l.byteLength,t.STATIC_DRAW)),t.bufferSubData(t.ARRAY_BUFFER,0,h),t.bufferSubData(t.ARRAY_BUFFER,T,l);var p=t.getAttribLocation(this.program,"aPos");t.enableVertexAttribArray(p),t.vertexAttribPointer(p,2,t.FLOAT,t.FALSE,0,0);var g=t.getAttribLocation(this.program,"aTexCoord");if(t.enableVertexAttribArray(g),t.vertexAttribPointer(g,2,t.FLOAT,t.FALSE,0,T),this.setupOutputTexture(),null!==this.subKernelOutputTextures)for(var c=this.extDrawBuffersMap=[t.COLOR_ATTACHMENT0],E=0;E<this.subKernelOutputTextures.length;E++){var _=this.subKernelOutputTextures[E];c.push(t.COLOR_ATTACHMENT0+E+1),t.activeTexture(t.TEXTURE0+arguments.length+E),t.bindTexture(t.TEXTURE_2D,_),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_S,t.CLAMP_TO_EDGE),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_T,t.CLAMP_TO_EDGE),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MIN_FILTER,t.NEAREST),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MAG_FILTER,t.NEAREST),this.floatOutput?t.texImage2D(t.TEXTURE_2D,0,t.RGBA,e[0],e[1],0,t.RGBA,t.FLOAT,null):t.texImage2D(t.TEXTURE_2D,0,t.RGBA,e[0],e[1],0,t.RGBA,t.UNSIGNED_BYTE,null)}}},{key:"run",value:function(){null===this.program&&this.build.apply(this,arguments);var e=this.paramNames,t=this.paramTypes,r=this.texSize,i=this._webGl;if(i.useProgram(this.program),i.scissor(0,0,r[0],r[1]),!this.hardcodeConstants){var n=this.getUniformLocation("uOutputDim");i.uniform3fv(n,this.threadDim);var u=this.getUniformLocation("uTexSize");i.uniform2fv(u,r)}var s=this.getUniformLocation("ratio");i.uniform2f(s,r[0]/this.maxTexSize[0],r[1]/this.maxTexSize[1]),this.argumentsLength=0;for(var a=0;a<e.length;a++)this._addArgument(arguments[a],t[a],e[a]);if(this.graphical)return i.bindRenderbuffer(i.RENDERBUFFER,null),i.bindFramebuffer(i.FRAMEBUFFER,null),void i.drawArrays(i.TRIANGLE_STRIP,0,4);i.bindFramebuffer(i.FRAMEBUFFER,this.framebuffer);var o=this.outputTexture;if(i.framebufferTexture2D(i.FRAMEBUFFER,i.COLOR_ATTACHMENT0,i.TEXTURE_2D,o,0),null!==this.subKernelOutputTextures){for(var h=0;h<this.subKernelOutputTextures.length;h++){var l=this.subKernelOutputTextures[h];i.framebufferTexture2D(i.FRAMEBUFFER,i.COLOR_ATTACHMENT0+h+1,i.TEXTURE_2D,l,0)}this.ext.drawBuffersWEBGL(this.extDrawBuffersMap)}if(i.drawArrays(i.TRIANGLE_STRIP,0,4),null!==this.subKernelOutputTextures){if(null!==this.subKernels){var T=[];T.result=this.renderOutput(o);for(var f=0;f<this.subKernels.length;f++)T.push(new Texture(this.subKernelOutputTextures[f],r,this.output,this._webGl));return T}if(null!==this.subKernelProperties){var p={result:this.renderOutput(o)},g=0;for(var c in this.subKernelProperties)this.subKernelProperties.hasOwnProperty(c)&&(p[c]=new Texture(this.subKernelOutputTextures[g],r,this.output,this._webGl),g++);return p}}return this.renderOutput(o)}},{key:"renderOutput",value:function(e){var t=this.texSize,r=this._webGl,i=this.threadDim,n=this.output;if(this.outputToTexture)return new Texture(e,t,n,this._webGl);var u=void 0;if(this.floatOutput)u=new Float32Array(t[0]*t[1]*4),r.readPixels(0,0,t[0],t[1],r.RGBA,r.FLOAT,u);else{var s=new Uint8Array(t[0]*t[1]*4);r.readPixels(0,0,t[0],t[1],r.RGBA,r.UNSIGNED_BYTE,s),u=new Float32Array(s.buffer)}if(u=u.subarray(0,i[0]*i[1]*i[2]),1===n.length)return u;if(2===n.length)return utils.splitArray(u,n[0]);if(3===n.length){return utils.splitArray(u,n[0]*n[1]).map(function(e){return utils.splitArray(e,n[0])})}}},{key:"getOutputTexture",value:function(){return this.getTextureCache("OUTPUT")}},{key:"detachOutputTexture",value:function(){this.detachTextureCache("OUTPUT")}},{key:"setupOutputTexture",value:function(){var e=this._webGl,t=this.texSize;this.detachOutputTexture(),this.outputTexture=this.getOutputTexture(),e.activeTexture(e.TEXTURE0+this.paramNames.length),e.bindTexture(e.TEXTURE_2D,this.outputTexture),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_S,e.CLAMP_TO_EDGE),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_T,e.CLAMP_TO_EDGE),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MIN_FILTER,e.NEAREST),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MAG_FILTER,e.NEAREST),this.floatOutput?e.texImage2D(e.TEXTURE_2D,0,e.RGBA,t[0],t[1],0,e.RGBA,e.FLOAT,null):e.texImage2D(e.TEXTURE_2D,0,e.RGBA,t[0],t[1],0,e.RGBA,e.UNSIGNED_BYTE,null)}},{key:"getArgumentTexture",value:function(e){return this.getTextureCache("ARGUMENT_"+e)}},{key:"getSubKernelTexture",value:function(e){return this.getTextureCache("SUB_KERNEL_"+e)}},{key:"getTextureCache",value:function(e){return this.outputToTexture?this._webGl.createTexture():this.textureCache.hasOwnProperty(e)?this.textureCache[e]:this.textureCache[e]=this._webGl.createTexture()}},{key:"detachTextureCache",value:function(e){delete this.textureCache[e]}},{key:"getUniformLocation",value:function(e){var t=this.programUniformLocationCache[e];return t||(t=this._webGl.getUniformLocation(this.program,e),this.programUniformLocationCache[e]=t),t}},{key:"_getFragShaderArtifactMap",value:function(e){return{HEADER:this._getHeaderString(),LOOP_MAX:this._getLoopMaxString(),CONSTANTS:this._getConstantsString(),DECODE32_ENDIANNESS:this._getDecode32EndiannessString(),ENCODE32_ENDIANNESS:this._getEncode32EndiannessString(),GET_WRAPAROUND:this._getGetWraparoundString(),GET_TEXTURE_CHANNEL:this._getGetTextureChannelString(),GET_TEXTURE_INDEX:this._getGetTextureIndexString(),GET_RESULT:this._getGetResultString(),MAIN_PARAMS:this._getMainParamsString(e),MAIN_CONSTANTS:this._getMainConstantsString(),KERNEL:this._getKernelString(),MAIN_RESULT:this._getMainResultString()}}},{key:"_addArgument",value:function(e,t,r){var i=this._webGl,n=this.getArgumentTexture(r);switch(e instanceof Texture&&(t="Texture"),t){case"Array":var u=utils.getDimensions(e,!0),s=utils.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},u);i.activeTexture(i.TEXTURE0+this.argumentsLength),i.bindTexture(i.TEXTURE_2D,n),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_WRAP_S,i.CLAMP_TO_EDGE),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_WRAP_T,i.CLAMP_TO_EDGE),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MIN_FILTER,i.NEAREST),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MAG_FILTER,i.NEAREST);var a=s[0]*s[1];this.floatTextures&&(a*=4);var o=new Float32Array(a);utils.flattenTo(e,o);var h=void 0;this.floatTextures?i.texImage2D(i.TEXTURE_2D,0,i.RGBA,s[0],s[1],0,i.RGBA,i.FLOAT,o):(h=new Uint8Array(o.buffer),i.texImage2D(i.TEXTURE_2D,0,i.RGBA,s[0],s[1],0,i.RGBA,i.UNSIGNED_BYTE,h));var l=this.getUniformLocation("user_"+r),T=this.getUniformLocation("user_"+r+"Size"),f=this.getUniformLocation("user_"+r+"Dim");this.hardcodeConstants||(i.uniform3fv(f,u),i.uniform2fv(T,s)),i.uniform1i(l,this.argumentsLength);break;case"Number":var p=this.getUniformLocation("user_"+r);i.uniform1f(p,e);break;case"Input":var g=e,c=g.size,E=utils.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},c);i.activeTexture(i.TEXTURE0+this.argumentsLength),i.bindTexture(i.TEXTURE_2D,n),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_WRAP_S,i.CLAMP_TO_EDGE),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_WRAP_T,i.CLAMP_TO_EDGE),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MIN_FILTER,i.NEAREST),i.texParameteri(i.TEXTURE_2D,i.TEXTURE_MAG_FILTER,i.NEAREST);var _=E[0]*E[1],x=void 0;if(this.floatTextures?(_*=4,x=new Float32Array(_),x.set(g.value)):x=g.value,this.floatTextures)i.texImage2D(i.TEXTURE_2D,0,i.RGBA,E[0],E[1],0,i.RGBA,i.FLOAT,x);else{var d=new Uint8Array(x.buffer);i.texImage2D(i.TEXTURE_2D,0,i.RGBA,E[0],E[1],0,i.RGBA,i.UNSIGNED_BYTE,d)}var m=this.getUniformLocation("user_"+r),S=this.getUniformLocation("user_"+r+"Size"),b=this.getUniformLocation("user_"+r+"Dim");this.hardcodeConstants||(i.uniform3fv(b,c),i.uniform2fv(S,E)),i.uniform1i(m,this.argumentsLength);break;case"Texture":var v=e,R=utils.getDimensions(v,!0),A=v.size;v.texture===this.outputTexture&&this.setupOutputTexture(),i.activeTexture(i.TEXTURE0+this.argumentsLength),i.bindTexture(i.TEXTURE_2D,v.texture);var O=this.getUniformLocation("user_"+r),D=this.getUniformLocation("user_"+r+"Size"),U=this.getUniformLocation("user_"+r+"Dim");i.uniform3fv(U,R),i.uniform2fv(D,A),i.uniform1i(O,this.argumentsLength);break;default:throw new Error("Input type not supported (WebGL): "+e)}this.argumentsLength++}},{key:"_getHeaderString",value:function(){return null!==this.subKernels||null!==this.subKernelProperties?"#extension GL_EXT_draw_buffers : require\n":""}},{key:"_getLoopMaxString",value:function(){return this.loopMaxIterations?" "+parseInt(this.loopMaxIterations)+".0;\n":" 1000.0;\n"}},{key:"_getConstantsString",value:function(){var e=[],t=this.threadDim,r=this.texSize;return this.hardcodeConstants?e.push("highp vec3 uOutputDim = vec3("+t[0]+","+t[1]+", "+t[2]+")","highp vec2 uTexSize = vec2("+r[0]+", "+r[1]+")"):e.push("uniform highp vec3 uOutputDim","uniform highp vec2 uTexSize"),this._linesToString(e)}},{key:"_getTextureCoordinate",value:function(){var e=this.subKernelOutputVariableNames;return null===e||e.length<1?"varying highp vec2 vTexCoord;\n":"out highp vec2 vTexCoord;\n"}},{key:"_getDecode32EndiannessString",value:function(){return"LE"===this.endianness?"":"  rgba.rgba = rgba.abgr;\n"}},{key:"_getEncode32EndiannessString",value:function(){return"LE"===this.endianness?"":"  rgba.rgba = rgba.abgr;\n"}},{key:"_getGetWraparoundString",value:function(){return this.wraparound?"  xyz = mod(xyz, texDim);\n":""}},{key:"_getGetTextureChannelString",value:function(){return this.floatTextures?this._linesToString(["  int channel = int(integerMod(index, 4.0))","  index = float(int(index) / 4)"]):""}},{key:"_getGetTextureIndexString",value:function(){return this.floatTextures?"  index = float(int(index)/4);\n":""}},{key:"_getGetResultString",value:function(){return this.floatTextures?this._linesToString(["  if (channel == 0) return texel.r","  if (channel == 1) return texel.g","  if (channel == 2) return texel.b","  if (channel == 3) return texel.a"]):"  return decode32(texel);\n"}},{key:"_getMainParamsString",value:function(e){for(var t=[],r=this.paramTypes,i=this.paramNames,n=0;n<i.length;n++){var u=e[n],s=i[n],a=r[n];if(this.hardcodeConstants)if("Array"===a||"Texture"===a){var o=utils.getDimensions(u,!0),h=utils.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},o);t.push("uniform highp sampler2D user_"+s,"highp vec2 user_"+s+"Size = vec2("+h[0]+".0, "+h[1]+".0)","highp vec3 user_"+s+"Dim = vec3("+o[0]+".0, "+o[1]+".0, "+o[2]+".0)")}else"Number"===a&&Number.isInteger(u)?t.push("highp float user_"+s+" = "+u+".0"):"Number"===a&&t.push("highp float user_"+s+" = "+u);else"Array"===a||"Texture"===a||"Input"===a?t.push("uniform highp sampler2D user_"+s,"uniform highp vec2 user_"+s+"Size","uniform highp vec3 user_"+s+"Dim"):"Number"===a&&t.push("uniform highp float user_"+s)}return this._linesToString(t)}},{key:"_getMainConstantsString",value:function(){var e=[];if(this.constants)for(var t in this.constants)if(this.constants.hasOwnProperty(t)){var r=parseFloat(this.constants[t]);Number.isInteger(r)?e.push("const float constants_"+t+" = "+parseInt(r)+".0"):e.push("const float constants_"+t+" = "+parseFloat(r))}return this._linesToString(e)}},{key:"_getKernelString",value:function(){var e=[],t=this.subKernelOutputVariableNames;if(null!==t){e.push("highp float kernelResult = 0.0");for(var r=0;r<t.length;r++)e.push("highp float "+t[r]+" = 0.0")}else e.push("highp float kernelResult = 0.0");return this._linesToString(e)+this.functionBuilder.getPrototypeString("kernel")}},{key:"_getMainResultString",value:function(){var e=this.subKernelOutputVariableNames,t=[];if(this.floatOutput&&t.push("  index *= 4.0"),this.graphical)t.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  gl_FragColor = actualColor");else if(this.floatOutput)for(var r=["r","g","b","a"],i=0;i<r.length;++i){if(t.push("  threadId = indexTo3D(index, uOutputDim)"),t.push("  kernel()"),e){t.push("  gl_FragData[0]."+r[i]+" = kernelResult");for(var n=0;n<e.length;++n)t.push("  gl_FragData["+(n+1)+"]."+r[i]+" = "+e[n])}else t.push("  gl_FragColor."+r[i]+" = kernelResult");i<r.length-1&&t.push("  index += 1.0")}else if(null!==e){t.push("  threadId = indexTo3D(index, uOutputDim)"),t.push("  kernel()"),t.push("  gl_FragData[0] = encode32(kernelResult)");for(var u=0;u<e.length;u++)t.push("  gl_FragData["+(u+1)+"] = encode32("+e[u]+")")}else t.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  gl_FragColor = encode32(kernelResult)");return this._linesToString(t)}},{key:"_linesToString",value:function(e){return e.length>0?e.join(";\n")+";\n":"\n"}},{key:"_replaceArtifacts",value:function(e,t){return e.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z])*)__;\n/g,function(e,r){if(t.hasOwnProperty(r))return t[r];throw"unhandled artifact "+r})}},{key:"_addKernels",value:function(){var e=this.functionBuilder,t=this._webGl;if(e.addFunctions(this.functions,{constants:this.constants,output:this.output}),e.addNativeFunctions(this.nativeFunctions),e.addKernel(this.fnString,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations},this.paramNames,this.paramTypes),null!==this.subKernels){if(!(this.ext=t.getExtension("WEBGL_draw_buffers")))throw new Error("could not instantiate draw buffers extension");this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[];for(var r=0;r<this.subKernels.length;r++){var i=this.subKernels[r];e.addSubKernel(i,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations}),this.subKernelOutputTextures.push(this.getSubKernelTexture(r)),this.subKernelOutputVariableNames.push(i.name+"Result")}}else if(null!==this.subKernelProperties){var n=this.ext=t.getExtension("WEBGL_draw_buffers");if(!n)throw new Error("could not instantiate draw buffers extension");this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[];var u=0;for(var s in this.subKernelProperties)if(this.subKernelProperties.hasOwnProperty(s)){var a=this.subKernelProperties[s];e.addSubKernel(a,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations}),this.subKernelOutputTextures.push(this.getSubKernelTexture(s)),this.subKernelOutputVariableNames.push(a.name+"Result"),u++}}}},{key:"_getFragShaderString",value:function(e){return null!==this.compiledFragShaderString?this.compiledFragShaderString:this.compiledFragShaderString=this._replaceArtifacts(fragShaderString,this._getFragShaderArtifactMap(e))}},{key:"_getVertShaderString",value:function(e){return null!==this.compiledVertShaderString?this.compiledVertShaderString:this.compiledVertShaderString=vertShaderString}},{key:"toString",value:function(){return kernelString(this)}},{key:"addFunction",value:function(e){this.functionBuilder.addFunction(null,e)}}]),t}(KernelBase);
 
-},{"../../core/texture":72,"../../core/utils":74,"../kernel-base":57,"./kernel-string":62,"./shader-frag":65,"./shader-vert":66}],64:[function(require,module,exports){
+},{"../../core/texture":73,"../../core/utils":75,"../kernel-base":58,"./kernel-string":63,"./shader-frag":66,"./shader-vert":67}],65:[function(require,module,exports){
 "use strict";function _classCallCheck(e,r){if(!(e instanceof r))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,r){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!r||"object"!=typeof r&&"function"!=typeof r?e:r}function _inherits(e,r){if("function"!=typeof r&&null!==r)throw new TypeError("Super expression must either be null or a function, not "+typeof r);e.prototype=Object.create(r&&r.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),r&&(Object.setPrototypeOf?Object.setPrototypeOf(e,r):e.__proto__=r)}var _createClass=function(){function e(e,r){for(var t=0;t<r.length;t++){var n=r[t];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(r,t,n){return t&&e(r.prototype,t),n&&e(r,n),r}}(),RunnerBase=require("../runner-base"),WebGLKernel=require("./kernel"),utils=require("../../core/utils"),WebGLFunctionBuilder=require("./function-builder");module.exports=function(e){function r(e){_classCallCheck(this,r);var t=_possibleConstructorReturn(this,(r.__proto__||Object.getPrototypeOf(r)).call(this,new WebGLFunctionBuilder,e));return t.Kernel=WebGLKernel,t.kernel=null,t}return _inherits(r,e),_createClass(r,[{key:"getMode",value:function(){return"gpu"}}]),r}(RunnerBase);
 
-},{"../../core/utils":74,"../runner-base":59,"./function-builder":60,"./kernel":63}],65:[function(require,module,exports){
+},{"../../core/utils":75,"../runner-base":60,"./function-builder":61,"./kernel":64}],66:[function(require,module,exports){
 "use strict";module.exports="__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n#define EPSILON 0.0000001;\n\n__CONSTANTS__;\n\nvarying highp vec2 vTexCoord;\n\nvec4 round(vec4 x) {\n  return floor(x + 0.5);\n}\n\nhighp float round(highp float x) {\n  return floor(x + 0.5);\n}\n\nvec2 integerMod(vec2 x, float y) {\n  vec2 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec3 integerMod(vec3 x, float y) {\n  vec3 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nvec4 integerMod(vec4 x, vec4 y) {\n  vec4 res = floor(mod(x, y));\n  return res * step(1.0 - floor(y), -res);\n}\n\nhighp float integerMod(highp float x, highp float y) {\n  highp float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nhighp int integerMod(highp int x, highp int y) {\n  return int(integerMod(float(x), float(y)));\n}\n\n// Here be dragons!\n// DO NOT OPTIMIZE THIS CODE\n// YOU WILL BREAK SOMETHING ON SOMEBODY'S MACHINE\n// LEAVE IT AS IT IS, LEST YOU WASTE YOUR OWN TIME\nconst vec2 MAGIC_VEC = vec2(1.0, -256.0);\nconst vec4 SCALE_FACTOR = vec4(1.0, 256.0, 65536.0, 0.0);\nconst vec4 SCALE_FACTOR_INV = vec4(1.0, 0.00390625, 0.0000152587890625, 0.0); // 1, 1/256, 1/65536\nhighp float decode32(highp vec4 rgba) {\n  __DECODE32_ENDIANNESS__;\n  rgba *= 255.0;\n  vec2 gte128;\n  gte128.x = rgba.b >= 128.0 ? 1.0 : 0.0;\n  gte128.y = rgba.a >= 128.0 ? 1.0 : 0.0;\n  float exponent = 2.0 * rgba.a - 127.0 + dot(gte128, MAGIC_VEC);\n  float res = exp2(round(exponent));\n  rgba.b = rgba.b - 128.0 * gte128.x;\n  res = dot(rgba, SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;\n  res *= gte128.y * -2.0 + 1.0;\n  return res;\n}\n\nhighp vec4 encode32(highp float f) {\n  highp float F = abs(f);\n  highp float sign = f < 0.0 ? 1.0 : 0.0;\n  highp float exponent = floor(log2(F));\n  highp float mantissa = (exp2(-exponent) * F);\n  // exponent += floor(log2(mantissa));\n  vec4 rgba = vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;\n  rgba.rg = integerMod(rgba.rg, 256.0);\n  rgba.b = integerMod(rgba.b, 128.0);\n  rgba.a = exponent*0.5 + 63.5;\n  rgba.ba += vec2(integerMod(exponent+127.0, 2.0), sign) * 128.0;\n  rgba = floor(rgba);\n  rgba *= 0.003921569; // 1/255\n  __ENCODE32_ENDIANNESS__;\n  return rgba;\n}\n// Dragons end here\n\nhighp float index;\nhighp vec3 threadId;\n\nhighp vec3 indexTo3D(highp float idx, highp vec3 texDim) {\n  highp float z = floor(idx / (texDim.x * texDim.y));\n  idx -= z * texDim.x * texDim.y;\n  highp float y = floor(idx / texDim.x);\n  highp float x = integerMod(idx, texDim.x);\n  return vec3(x, y, z);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float z, highp float y, highp float x) {\n  highp vec3 xyz = vec3(x, y, z);\n  xyz = floor(xyz + 0.5);\n  __GET_WRAPAROUND__;\n  highp float index = round(xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z));\n  __GET_TEXTURE_CHANNEL__;\n  highp float w = round(texSize.x);\n  vec2 st = vec2(integerMod(index, w), float(int(index) / int(w))) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  highp vec4 texel = texture2D(tex, st / texSize);\n  __GET_RESULT__;\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float y, highp float x) {\n  return get(tex, texSize, texDim, 0.0, y, x);\n}\n\nhighp float get(highp sampler2D tex, highp vec2 texSize, highp vec3 texDim, highp float x) {\n  return get(tex, texSize, texDim, 0.0, 0.0, x);\n}\n\nhighp vec4 actualColor;\nvoid color(float r, float g, float b, float a) {\n  actualColor = vec4(r,g,b,a);\n}\n\nvoid color(float r, float g, float b) {\n  color(r,g,b,1.0);\n}\n\n__MAIN_PARAMS__;\n__MAIN_CONSTANTS__;\n__KERNEL__;\n\nvoid main(void) {\n  index = floor(vTexCoord.s * float(uTexSize.x)) + floor(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
 
-},{}],66:[function(require,module,exports){
+},{}],67:[function(require,module,exports){
 "use strict";module.exports="precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nattribute highp vec2 aPos;\nattribute highp vec2 aTexCoord;\n\nvarying highp vec2 vTexCoord;\nuniform vec2 ratio;\n\nvoid main(void) {\n  gl_Position = vec4((aPos + vec2(1)) * ratio + vec2(-1), 0, 1);\n  vTexCoord = aTexCoord;\n}";
 
-},{}],67:[function(require,module,exports){
+},{}],68:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var _createClass=function(){function e(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(t,r,n){return r&&e(t.prototype,r),n&&e(t,n),t}}(),WebGLKernel=require("./kernel"),utils=require("../../core/utils");module.exports=function(e){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return _inherits(t,e),_createClass(t,[{key:"validateOptions",value:function(){this.texSize=utils.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},this.output,!0)}}]),t}(WebGLKernel);
 
-},{"../../core/utils":74,"./kernel":63}],68:[function(require,module,exports){
+},{"../../core/utils":75,"./kernel":64}],69:[function(require,module,exports){
 "use strict";var utils=require("./utils");module.exports=function(t,r){var n=r.toString();return new Function("return function "+t+" ("+utils.getParamNamesFromString(n).join(", ")+") {"+utils.getFunctionBodyFromString(n)+"}")()};
 
-},{"./utils":74}],69:[function(require,module,exports){
+},{"./utils":75}],70:[function(require,module,exports){
 "use strict";function _classCallCheck(e,r){if(!(e instanceof r))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,r){for(var n=0;n<r.length;n++){var t=r[n];t.enumerable=t.enumerable||!1,t.configurable=!0,"value"in t&&(t.writable=!0),Object.defineProperty(e,t.key,t)}}return function(r,n,t){return n&&e(r.prototype,n),t&&e(r,t),r}}(),UtilsCore=require("./utils-core");module.exports=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"validateKernelObj",value:function(e){if(null===e)throw"KernelObj being validated is NULL";if("string"==typeof e){try{e=JSON.parse(e)}catch(e){throw console.error(e),"Failed to convert KernelObj from JSON string"}if(null===e)throw"Invalid (NULL) KernelObj JSON string representation"}if(!0!==e.isKernelObj)throw"Failed missing isKernelObj flag check";return e}},{key:"loadKernelObj",value:function(e,r){e=validateKernelObj(e)}}]),e}();
 
-},{"./utils-core":73}],70:[function(require,module,exports){
+},{"./utils-core":74}],71:[function(require,module,exports){
 "use strict";function _classCallCheck(e,r){if(!(e instanceof r))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,r){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!r||"object"!=typeof r&&"function"!=typeof r?e:r}function _inherits(e,r){if("function"!=typeof r&&null!==r)throw new TypeError("Super expression must either be null or a function, not "+typeof r);e.prototype=Object.create(r&&r.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),r&&(Object.setPrototypeOf?Object.setPrototypeOf(e,r):e.__proto__=r)}var _createClass=function(){function e(e,r){for(var n=0;n<r.length;n++){var t=r[n];t.enumerable=t.enumerable||!1,t.configurable=!0,"value"in t&&(t.writable=!0),Object.defineProperty(e,t.key,t)}}return function(r,n,t){return n&&e(r.prototype,n),t&&e(r,t),r}}(),utils=require("./utils"),WebGLRunner=require("../backend/web-gl/runner"),CPURunner=require("../backend/cpu/runner"),WebGLValidatorKernel=require("../backend/web-gl/validator-kernel"),GPUCore=require("./gpu-core"),GPU=function(e){function r(e){_classCallCheck(this,r);var n=_possibleConstructorReturn(this,(r.__proto__||Object.getPrototypeOf(r)).call(this,e));e=e||{},n._canvas=e.canvas||null,n._webGl=e.webGl||null;var t=e.mode,u=void 0;if(utils.isWebGlSupported())u=t||"gpu";else{if(t&&"cpu"!==t)throw new Error('A requested mode of "'+t+'" and is not supported');console.warn("Warning: gpu not supported, falling back to cpu support"),u="cpu"}n.kernels=[];var a={canvas:n._canvas,webGl:n._webGl};switch(u){case"cpu":n._runner=new CPURunner(a);break;case"webgl":case"gpu":n._runner=new WebGLRunner(a);break;case"webgl-validator":n._runner=new WebGLRunner(a),n._runner.Kernel=WebGLValidatorKernel;break;default:throw new Error('"'+t+'" mode is not defined')}return n}return _inherits(r,e),_createClass(r,[{key:"createKernel",value:function(e,r){if(void 0===e)throw"Missing fn parameter";if(!utils.isFunction(e)&&"string"!=typeof e)throw"fn parameter not a function";var n=this._runner.buildKernel(e,r||{});return this._canvas||(this._canvas=n.getCanvas()),this._runner.canvas||(this._runner.canvas=n.getCanvas()),this.kernels.push(n),n}},{key:"createKernelMap",value:function(){var e=void 0,r=void 0;"function"==typeof arguments[arguments.length-2]?(e=arguments[arguments.length-2],r=arguments[arguments.length-1]):e=arguments[arguments.length-1],utils.isWebGlDrawBuffersSupported()||(this._runner=new CPURunner(r));var n=this.createKernel(e,r);if(Array.isArray(arguments[0]))for(var t=arguments[0],u=0;u<t.length;u++)n.addSubKernel(t[u]);else{var a=arguments[0];for(var i in a)a.hasOwnProperty(i)&&n.addSubKernelProperty(i,a[i])}return n}},{key:"combineKernels",value:function(){var e=arguments[arguments.length-2],r=arguments[arguments.length-1];if("cpu"===this.getMode())return r;for(var n=arguments[0].getCanvas(),t=arguments[0].getWebGl(),u=0;u<arguments.length-1;u++)arguments[u].setCanvas(n).setWebGl(t).setOutputToTexture(!0);return function(){r.apply(null,arguments);var n=e.texSize,t=e.getWebGl(),u=e.threadDim,a=void 0;if(e.floatOutput)a=new Float32Array(n[0]*n[1]*4),t.readPixels(0,0,n[0],n[1],t.RGBA,t.FLOAT,a);else{var i=new Uint8Array(n[0]*n[1]*4);t.readPixels(0,0,n[0],n[1],t.RGBA,t.UNSIGNED_BYTE,i),a=new Float32Array(i.buffer)}if(a=a.subarray(0,u[0]*u[1]*u[2]),1===e.output.length)return a;if(2===e.output.length)return utils.splitArray(a,e.output[0]);if(3===e.output.length){return utils.splitArray(a,e.output[0]*e.output[1]).map(function(r){return utils.splitArray(r,e.output[0])})}}}},{key:"addFunction",value:function(e,r,n){return this._runner.functionBuilder.addFunction(null,e,r,n),this}},{key:"addNativeFunction",value:function(e,r){return this._runner.functionBuilder.addNativeFunction(e,r),this}},{key:"getMode",value:function(){return this._runner.getMode()}},{key:"isWebGlSupported",value:function(){return utils.isWebGlSupported()}},{key:"getCanvas",value:function(){return this._canvas}},{key:"getWebGl",value:function(){return this._webGl}}]),r}(GPUCore);Object.assign(GPU,GPUCore),module.exports=GPU;
 
-},{"../backend/cpu/runner":54,"../backend/web-gl/runner":64,"../backend/web-gl/validator-kernel":67,"./gpu-core":69,"./utils":74}],71:[function(require,module,exports){
+},{"../backend/cpu/runner":55,"../backend/web-gl/runner":65,"../backend/web-gl/validator-kernel":68,"./gpu-core":70,"./utils":75}],72:[function(require,module,exports){
 "use strict";function _classCallCheck(s,i){if(!(s instanceof i))throw new TypeError("Cannot call a class as a function")}module.exports=function s(i,e){if(_classCallCheck(this,s),this.value=i,Array.isArray(e)){this.size=[];for(var t=0;t<e.length;t++)this.size[t]=e[t];for(;this.size.length<3;)this.size.push(1)}else e.z?this.size=[e.x,e.y,e.z]:e.y?this.size=[e.x,e.y,1]:this.size=[e.x,1,1]};
 
-},{}],72:[function(require,module,exports){
+},{}],73:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(t,r,n){return r&&e(t.prototype,r),n&&e(t,n),t}}(),gpu=null;module.exports=function(){function e(t,r,n,i){_classCallCheck(this,e),this.texture=t,this.size=r,this.output=n,this.webGl=i,this.kernel=null}return _createClass(e,[{key:"toArray",value:function(e){if(!e)throw new Error("You need to pass the GPU object for toArray to work.");return this.kernel?this.kernel(this):(this.kernel=e.createKernel(function(e){return e[this.thread.z][this.thread.y][this.thread.x]}).setOutput(this.output),this.kernel(this))}},{key:"delete",value:function(){return this.webGl.deleteTexture(this.texture)}}]),e}();
 
-},{}],73:[function(require,module,exports){
+},{}],74:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,t){for(var n=0;n<t.length;n++){var i=t[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(e,i.key,i)}}return function(t,n,i){return n&&e(t.prototype,n),i&&e(t,i),t}}(),UtilsCore=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"isCanvas",value:function(e){return null!==e&&e.nodeName&&e.getContext&&"CANVAS"===e.nodeName.toUpperCase()}},{key:"isCanvasSupported",value:function(){return _isCanvasSupported}},{key:"initCanvas",value:function(){if(!_isCanvasSupported)return null;var e=document.createElement("canvas");return e.width=2,e.height=2,e}},{key:"isWebGl",value:function(e){return e&&"function"==typeof e.getExtension}},{key:"isWebGlSupported",value:function(){return _isWebGlSupported}},{key:"isWebGlDrawBuffersSupported",value:function(){return _isWebGlDrawBuffersSupported}},{key:"initWebGlDefaultOptions",value:function(){return{alpha:!1,depth:!1,antialias:!1}}},{key:"initWebGl",value:function(t){if((void 0!==_isCanvasSupported||null===t)&&!_isCanvasSupported)return null;if(!e.isCanvas(t))throw new Error("Invalid canvas object - "+t);var n=t.getContext("experimental-webgl",e.initWebGlDefaultOptions())||t.getContext("webgl",e.initWebGlDefaultOptions());return n&&(n.OES_texture_float=n.getExtension("OES_texture_float"),n.OES_texture_float_linear=n.getExtension("OES_texture_float_linear"),n.OES_element_index_uint=n.getExtension("OES_element_index_uint")),n}}]),e}(),_isCanvasSupported="undefined"!=typeof document&&UtilsCore.isCanvas(document.createElement("canvas")),_testingWebGl=UtilsCore.initWebGl(UtilsCore.initCanvas()),_isWebGlSupported=UtilsCore.isWebGl(_testingWebGl),_isWebGlDrawBuffersSupported=_isWebGlSupported&&Boolean(_testingWebGl.getExtension("WEBGL_draw_buffers"));_isWebGlSupported?(UtilsCore.OES_texture_float=_testingWebGl.OES_texture_float,UtilsCore.OES_texture_float_linear=_testingWebGl.OES_texture_float_linear,UtilsCore.OES_element_index_uint=_testingWebGl.OES_element_index_uint):(UtilsCore.OES_texture_float=!1,UtilsCore.OES_texture_float_linear=!1,UtilsCore.OES_element_index_uint=!1),module.exports=UtilsCore;
 
-},{}],74:[function(require,module,exports){
+},{}],75:[function(require,module,exports){
 "use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_createClass=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),UtilsCore=require("./utils-core"),Input=require("./input"),Texture=require("./texture"),FUNCTION_NAME=/function ([^(]*)/,STRIP_COMMENTS=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,ARGUMENT_NAMES=/([^\s,]+)/g,_systemEndianness=function(){var e=new ArrayBuffer(4),t=new Uint32Array(e),n=new Uint8Array(e);if(t[0]=3735928559,239===n[0])return"LE";if(222===n[0])return"BE";throw new Error("unknown endianness")}(),_isFloatReadPixelsSupported=null,_isMixedIdentifiersSupported=function(){try{return new Function("let i = 1; const j = 1;")(),!0}catch(e){return!1}}(),Utils=function(e){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return _inherits(t,e),_createClass(t,null,[{key:"systemEndianness",value:function(){return _systemEndianness}},{key:"isFunction",value:function(e){return"function"==typeof e}},{key:"isFunctionString",value:function(e){return null!==e&&"function"===e.toString().slice(0,"function".length).toLowerCase()}},{key:"getFunctionNameFromString",value:function(e){return FUNCTION_NAME.exec(e)[1]}},{key:"getFunctionBodyFromString",value:function(e){return e.substring(e.indexOf("{")+1,e.lastIndexOf("}"))}},{key:"getParamNamesFromString",value:function(e){var t=e.toString().replace(STRIP_COMMENTS,""),n=t.slice(t.indexOf("(")+1,t.indexOf(")")).match(ARGUMENT_NAMES);return null===n&&(n=[]),n}},{key:"clone",value:function(e){if(null===e||"object"!==(void 0===e?"undefined":_typeof(e))||e.hasOwnProperty("isActiveClone"))return e;var n=e.constructor();for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&(e.isActiveClone=null,n[r]=t.clone(e[r]),delete e.isActiveClone);return n}},{key:"newPromise",value:function(e){var t=Promise||small_promise;if(null===t)throw TypeError("Browser is missing Promise implementation. Consider adding small_promise.js polyfill");return new t(e)}},{key:"functionBinder",value:function(e,t){return e.bind?e.bind(t):function(){var n=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);return e.apply(t,n)}}},{key:"isArray",value:function(e){return!isNaN(e.length)}},{key:"getArgumentType",value:function(e){return t.isArray(e)?"Array":"number"==typeof e?"Number":e instanceof Texture?"Texture":e instanceof Input?"Input":"Unknown"}},{key:"isFloatReadPixelsSupported",value:function(){if(null!==_isFloatReadPixelsSupported)return _isFloatReadPixelsSupported;var e=require("../index"),t=new e({mode:"webgl-validator"}).createKernel(function(){return 1},{output:[2],floatTextures:!0,floatOutput:!0,floatOutputForce:!0})();return _isFloatReadPixelsSupported=1===t[0]}},{key:"isMixedIdentifiersSupported",value:function(){return _isMixedIdentifiersSupported}},{key:"dimToTexSize",value:function(e,t,n){for(var r=t[0],o=1;o<t.length;o++)r*=t[o];!e.floatTextures||n&&!e.floatOutput||(r=Math.ceil(r/4));var i=Math.ceil(Math.sqrt(r));return[i,i]}},{key:"getDimensions",value:function(e,n){var r=void 0;if(t.isArray(e)){for(var o=[],i=e;t.isArray(i);)o.push(i.length),i=i[0];r=o.reverse()}else if(e instanceof Texture)r=e.output;else{if(!(e instanceof Input))throw"Unknown dimensions of "+e;r=e.size}if(n)for(r=t.clone(r);r.length<3;)r.push(1);return r}},{key:"pad",value:function(e,t){function n(e){return Array.apply(null,new Array(e)).map(Number.prototype.valueOf,0)}for(var r=e.length+2*t,o=e.map(function(e){return[].concat(n(t),e,n(t))}),i=0;i<t;i++)o=[].concat([n(r)],o,[n(r)]);return o}},{key:"flatten2dArrayTo",value:function(e,t){for(var n=0,r=0;r<e.length;r++)t.set(e[r],n),n+=e[r].length}},{key:"flatten3dArrayTo",value:function(e,t){for(var n=0,r=0;r<e.length;r++)for(var o=0;o<e[r].length;o++)t.set(e[r][o],n),n+=e[r][o].length}},{key:"flattenTo",value:function(e,n){t.isArray(e[0])?t.isArray(e[0][0])?t.flatten3dArrayTo(e,n):t.flatten2dArrayTo(e,n):n.set(e)}},{key:"splitArray",value:function(e,t){for(var n=[],r=0;r<e.length;r+=t)n.push(Array.prototype.slice.call(e,r,r+t));return n}},{key:"getAstString",value:function(e,t){var n=Array.isArray(e)?e:e.split(/\r?\n/g),r=t.loc.start,o=t.loc.end,i=[];i.push(n[r.line-1].slice(r.column));for(var u=r.line;u<o.line-1;u++)i.push(n[u]);return i.push(n[o.line-1].slice(0,o.column)),i.join("\n")}},{key:"allPropertiesOf",value:function(e){var t=[];do{t.push.apply(t,Object.getOwnPropertyNames(e))}while(e=Object.getPrototypeOf(e));return t}}]),t}(UtilsCore);Object.assign(Utils,UtilsCore),module.exports=Utils;
 
-},{"../index":75,"./input":71,"./texture":72,"./utils-core":73}],75:[function(require,module,exports){
+},{"../index":76,"./input":72,"./texture":73,"./utils-core":74}],76:[function(require,module,exports){
 "use strict";var GPU=require("./core/gpu"),alias=require("./core/alias"),utils=require("./core/utils"),Input=require("./core/input"),Texture=require("./core/texture"),CPUFunctionBuilder=require("./backend/cpu/function-builder"),CPUFunctionNode=require("./backend/cpu/function-node"),CPUKernel=require("./backend/cpu/kernel"),CPURunner=require("./backend/cpu/runner"),WebGLFunctionBuilder=require("./backend/web-gl/function-builder"),WebGLFunctionNode=require("./backend/web-gl/function-node"),WebGLKernel=require("./backend/web-gl/kernel"),WebGLRunner=require("./backend/web-gl/runner");GPU.alias=alias,GPU.utils=utils,GPU.Texture=Texture,GPU.Input=Input,GPU.input=function(e,n){return new Input(e,n)},GPU.CPUFunctionBuilder=CPUFunctionBuilder,GPU.CPUFunctionNode=CPUFunctionNode,GPU.CPUKernel=CPUKernel,GPU.CPURunner=CPURunner,GPU.WebGLFunctionBuilder=WebGLFunctionBuilder,GPU.WebGLFunctionNode=WebGLFunctionNode,GPU.WebGLKernel=WebGLKernel,GPU.WebGLRunner=WebGLRunner,"undefined"!=typeof module&&(module.exports=GPU),"undefined"!=typeof window&&(window.GPU=GPU);
-},{"./backend/cpu/function-builder":50,"./backend/cpu/function-node":51,"./backend/cpu/kernel":53,"./backend/cpu/runner":54,"./backend/web-gl/function-builder":60,"./backend/web-gl/function-node":61,"./backend/web-gl/kernel":63,"./backend/web-gl/runner":64,"./core/alias":68,"./core/gpu":70,"./core/input":71,"./core/texture":72,"./core/utils":74}],76:[function(require,module,exports){
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e(t.acorn={})}(this,function(t){"use strict";function e(t,e){for(var s=65536,i=0;i<e.length;i+=2){if((s+=e[i])>t)return!1;if((s+=e[i+1])>=t)return!0}}function s(t,s){return t<65?36===t:t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&C.test(String.fromCharCode(t)):!1!==s&&e(t,_)))}function i(t,s){return t<48?36===t:t<58||!(t<65)&&(t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&L.test(String.fromCharCode(t)):!1!==s&&(e(t,_)||e(t,P)))))}function r(t,e){return new T(t,{beforeExpr:!0,binop:e})}function n(t,e){return void 0===e&&(e={}),e.keyword=t,R[t]=new T(t,e)}function a(t){return 10===t||13===t||8232===t||8233===t}function o(t,e){return q.call(t,e)}function h(t,e){for(var s=1,i=0;;){D.lastIndex=i;var r=D.exec(t);if(!(r&&r.index<e))return new j(s,e-i);++s,i=r.index+r[0].length}}function p(t){var e={};for(var s in G)e[s]=t&&o(t,s)?t[s]:G[s];if(e.ecmaVersion>=2015&&(e.ecmaVersion-=2009),null==e.allowReserved&&(e.allowReserved=e.ecmaVersion<5),z(e.onToken)){var i=e.onToken;e.onToken=function(t){return i.push(t)}}return z(e.onComment)&&(e.onComment=c(e,e.onComment)),e}function c(t,e){return function(s,i,r,n,a,o){var h={type:s?"Block":"Line",value:i,start:r,end:n};t.locations&&(h.loc=new W(this,a,o)),t.ranges&&(h.range=[r,n]),e.push(h)}}function l(t){return new RegExp("^(?:"+t.replace(/ /g,"|")+")$")}function u(){this.shorthandAssign=this.trailingComma=this.parenthesizedAssign=this.parenthesizedBind=this.doubleProto=-1}function d(t,e,s,i){return t.type=e,t.end=s,this.options.locations&&(t.loc.end=i),this.options.ranges&&(t.range[1]=s),t}function f(t,e,s,i){try{return new RegExp(t,e)}catch(t){if(void 0!==s)throw t instanceof SyntaxError&&i.raise(s,"Error parsing regular expression: "+t.message),t}}function m(t){return t<=65535?String.fromCharCode(t):(t-=65536,String.fromCharCode(55296+(t>>10),56320+(1023&t)))}function x(t,e){return new $(e,t).parse()}function y(t,e,s){var i=new $(s,t,e);return i.nextToken(),i.parseExpression()}function v(t,e){return new $(e,t)}function b(e,s,i){t.parse_dammit=e,t.LooseParser=s,t.pluginsLoose=i}var g={3:"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",5:"class enum extends super const export import",6:"enum",strict:"implements interface let package private protected public static yield",strictBind:"eval arguments"},k="break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this",w={5:k,6:k+" const class extends export import super"},E=/^in(stanceof)?$/,A="ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢴࢶ-ࢽऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞮꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ",S="‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣔ-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿",C=new RegExp("["+A+"]"),L=new RegExp("["+A+S+"]");A=S=null;var _=[0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541],P=[509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239],T=function(t,e){void 0===e&&(e={}),this.label=t,this.keyword=e.keyword,this.beforeExpr=!!e.beforeExpr,this.startsExpr=!!e.startsExpr,this.isLoop=!!e.isLoop,this.isAssign=!!e.isAssign,this.prefix=!!e.prefix,this.postfix=!!e.postfix,this.binop=e.binop||null,this.updateContext=null},N={beforeExpr:!0},I={startsExpr:!0},R={},V={num:new T("num",I),regexp:new T("regexp",I),string:new T("string",I),name:new T("name",I),eof:new T("eof"),bracketL:new T("[",{beforeExpr:!0,startsExpr:!0}),bracketR:new T("]"),braceL:new T("{",{beforeExpr:!0,startsExpr:!0}),braceR:new T("}"),parenL:new T("(",{beforeExpr:!0,startsExpr:!0}),parenR:new T(")"),comma:new T(",",N),semi:new T(";",N),colon:new T(":",N),dot:new T("."),question:new T("?",N),arrow:new T("=>",N),template:new T("template"),invalidTemplate:new T("invalidTemplate"),ellipsis:new T("...",N),backQuote:new T("`",I),dollarBraceL:new T("${",{beforeExpr:!0,startsExpr:!0}),eq:new T("=",{beforeExpr:!0,isAssign:!0}),assign:new T("_=",{beforeExpr:!0,isAssign:!0}),incDec:new T("++/--",{prefix:!0,postfix:!0,startsExpr:!0}),prefix:new T("!/~",{beforeExpr:!0,prefix:!0,startsExpr:!0}),logicalOR:r("||",1),logicalAND:r("&&",2),bitwiseOR:r("|",3),bitwiseXOR:r("^",4),bitwiseAND:r("&",5),equality:r("==/!=/===/!==",6),relational:r("</>/<=/>=",7),bitShift:r("<</>>/>>>",8),plusMin:new T("+/-",{beforeExpr:!0,binop:9,prefix:!0,startsExpr:!0}),modulo:r("%",10),star:r("*",10),slash:r("/",10),starstar:new T("**",{beforeExpr:!0}),_break:n("break"),_case:n("case",N),_catch:n("catch"),_continue:n("continue"),_debugger:n("debugger"),_default:n("default",N),_do:n("do",{isLoop:!0,beforeExpr:!0}),_else:n("else",N),_finally:n("finally"),_for:n("for",{isLoop:!0}),_function:n("function",I),_if:n("if"),_return:n("return",N),_switch:n("switch"),_throw:n("throw",N),_try:n("try"),_var:n("var"),_const:n("const"),_while:n("while",{isLoop:!0}),_with:n("with"),_new:n("new",{beforeExpr:!0,startsExpr:!0}),_this:n("this",I),_super:n("super",I),_class:n("class",I),_extends:n("extends",N),_export:n("export"),_import:n("import"),_null:n("null",I),_true:n("true",I),_false:n("false",I),_in:n("in",{beforeExpr:!0,binop:7}),_instanceof:n("instanceof",{beforeExpr:!0,binop:7}),_typeof:n("typeof",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_void:n("void",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_delete:n("delete",{beforeExpr:!0,prefix:!0,startsExpr:!0})},F=/\r\n?|\n|\u2028|\u2029/,D=new RegExp(F.source,"g"),B=/[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/,O=/(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g,M=Object.prototype,q=M.hasOwnProperty,U=M.toString,z=Array.isArray||function(t){return"[object Array]"===U.call(t)},j=function(t,e){this.line=t,this.column=e};j.prototype.offset=function(t){return new j(this.line,this.column+t)};var W=function(t,e,s){this.start=e,this.end=s,null!==t.sourceFile&&(this.source=t.sourceFile)},G={ecmaVersion:7,sourceType:"script",onInsertedSemicolon:null,onTrailingComma:null,allowReserved:null,allowReturnOutsideFunction:!1,allowImportExportEverywhere:!1,allowHashBang:!1,locations:!1,onToken:null,onComment:null,ranges:!1,program:null,sourceFile:null,directSourceFile:null,preserveParens:!1,plugins:{}},Y={},$=function(t,e,s){this.options=t=p(t),this.sourceFile=t.sourceFile,this.keywords=l(w[t.ecmaVersion>=6?6:5]);var i="";if(!t.allowReserved){for(var r=t.ecmaVersion;!(i=g[r]);r--);"module"==t.sourceType&&(i+=" await")}this.reservedWords=l(i);var n=(i?i+" ":"")+g.strict;this.reservedWordsStrict=l(n),this.reservedWordsStrictBind=l(n+" "+g.strictBind),this.input=String(e),this.containsEsc=!1,this.loadPlugins(t.plugins),s?(this.pos=s,this.lineStart=this.input.lastIndexOf("\n",s-1)+1,this.curLine=this.input.slice(0,this.lineStart).split(F).length):(this.pos=this.lineStart=0,this.curLine=1),this.type=V.eof,this.value=null,this.start=this.end=this.pos,this.startLoc=this.endLoc=this.curPosition(),this.lastTokEndLoc=this.lastTokStartLoc=null,this.lastTokStart=this.lastTokEnd=this.pos,this.context=this.initialContext(),this.exprAllowed=!0,this.inModule="module"===t.sourceType,this.strict=this.inModule||this.strictDirective(this.pos),this.potentialArrowAt=-1,this.inFunction=this.inGenerator=this.inAsync=!1,this.yieldPos=this.awaitPos=0,this.labels=[],0===this.pos&&t.allowHashBang&&"#!"===this.input.slice(0,2)&&this.skipLineComment(2),this.scopeStack=[],this.enterFunctionScope()};$.prototype.isKeyword=function(t){return this.keywords.test(t)},$.prototype.isReservedWord=function(t){return this.reservedWords.test(t)},$.prototype.extend=function(t,e){this[t]=e(this[t])},$.prototype.loadPlugins=function(t){var e=this;for(var s in t){var i=Y[s];if(!i)throw new Error("Plugin '"+s+"' not found");i(e,t[s])}},$.prototype.parse=function(){var t=this.options.program||this.startNode();return this.nextToken(),this.parseTopLevel(t)};var Q=$.prototype,H=/^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;Q.strictDirective=function(t){for(var e=this;;){O.lastIndex=t,t+=O.exec(e.input)[0].length;var s=H.exec(e.input.slice(t));if(!s)return!1;if("use strict"==(s[1]||s[2]))return!0;t+=s[0].length}},Q.eat=function(t){return this.type===t&&(this.next(),!0)},Q.isContextual=function(t){return this.type===V.name&&this.value===t&&!this.containsEsc},Q.eatContextual=function(t){return!!this.isContextual(t)&&(this.next(),!0)},Q.expectContextual=function(t){this.eatContextual(t)||this.unexpected()},Q.canInsertSemicolon=function(){return this.type===V.eof||this.type===V.braceR||F.test(this.input.slice(this.lastTokEnd,this.start))},Q.insertSemicolon=function(){if(this.canInsertSemicolon())return this.options.onInsertedSemicolon&&this.options.onInsertedSemicolon(this.lastTokEnd,this.lastTokEndLoc),!0},Q.semicolon=function(){this.eat(V.semi)||this.insertSemicolon()||this.unexpected()},Q.afterTrailingComma=function(t,e){if(this.type==t)return this.options.onTrailingComma&&this.options.onTrailingComma(this.lastTokStart,this.lastTokStartLoc),e||this.next(),!0},Q.expect=function(t){this.eat(t)||this.unexpected()},Q.unexpected=function(t){this.raise(null!=t?t:this.start,"Unexpected token")},Q.checkPatternErrors=function(t,e){if(t){t.trailingComma>-1&&this.raiseRecoverable(t.trailingComma,"Comma is not permitted after the rest element");var s=e?t.parenthesizedAssign:t.parenthesizedBind;s>-1&&this.raiseRecoverable(s,"Parenthesized pattern")}},Q.checkExpressionErrors=function(t,e){if(!t)return!1;var s=t.shorthandAssign,i=t.doubleProto;if(!e)return s>=0||i>=0;s>=0&&this.raise(s,"Shorthand property assignments are valid only in destructuring patterns"),i>=0&&this.raiseRecoverable(i,"Redefinition of __proto__ property")},Q.checkYieldAwaitInDefaultParams=function(){this.yieldPos&&(!this.awaitPos||this.yieldPos<this.awaitPos)&&this.raise(this.yieldPos,"Yield expression cannot be a default value"),this.awaitPos&&this.raise(this.awaitPos,"Await expression cannot be a default value")},Q.isSimpleAssignTarget=function(t){return"ParenthesizedExpression"===t.type?this.isSimpleAssignTarget(t.expression):"Identifier"===t.type||"MemberExpression"===t.type};var X=$.prototype;X.parseTopLevel=function(t){var e=this,s={};for(t.body||(t.body=[]);this.type!==V.eof;){var i=e.parseStatement(!0,!0,s);t.body.push(i)}return this.adaptDirectivePrologue(t.body),this.next(),this.options.ecmaVersion>=6&&(t.sourceType=this.options.sourceType),this.finishNode(t,"Program")};var K={kind:"loop"},J={kind:"switch"};X.isLet=function(){if(this.options.ecmaVersion<6||!this.isContextual("let"))return!1;O.lastIndex=this.pos;var t=O.exec(this.input),e=this.pos+t[0].length,r=this.input.charCodeAt(e);if(91===r||123==r)return!0;if(s(r,!0)){for(var n=e+1;i(this.input.charCodeAt(n),!0);)++n;var a=this.input.slice(e,n);if(!E.test(a))return!0}return!1},X.isAsyncFunction=function(){if(this.options.ecmaVersion<8||!this.isContextual("async"))return!1;O.lastIndex=this.pos;var t=O.exec(this.input),e=this.pos+t[0].length;return!(F.test(this.input.slice(this.pos,e))||"function"!==this.input.slice(e,e+8)||e+8!=this.input.length&&i(this.input.charAt(e+8)))},X.parseStatement=function(t,e,s){var i,r=this.type,n=this.startNode();switch(this.isLet()&&(r=V._var,i="let"),r){case V._break:case V._continue:return this.parseBreakContinueStatement(n,r.keyword);case V._debugger:return this.parseDebuggerStatement(n);case V._do:return this.parseDoStatement(n);case V._for:return this.parseForStatement(n);case V._function:return!t&&this.options.ecmaVersion>=6&&this.unexpected(),this.parseFunctionStatement(n,!1);case V._class:return t||this.unexpected(),this.parseClass(n,!0);case V._if:return this.parseIfStatement(n);case V._return:return this.parseReturnStatement(n);case V._switch:return this.parseSwitchStatement(n);case V._throw:return this.parseThrowStatement(n);case V._try:return this.parseTryStatement(n);case V._const:case V._var:return i=i||this.value,t||"var"==i||this.unexpected(),this.parseVarStatement(n,i);case V._while:return this.parseWhileStatement(n);case V._with:return this.parseWithStatement(n);case V.braceL:return this.parseBlock();case V.semi:return this.parseEmptyStatement(n);case V._export:case V._import:return this.options.allowImportExportEverywhere||(e||this.raise(this.start,"'import' and 'export' may only appear at the top level"),this.inModule||this.raise(this.start,"'import' and 'export' may appear only with 'sourceType: module'")),r===V._import?this.parseImport(n):this.parseExport(n,s);default:if(this.isAsyncFunction())return t||this.unexpected(),this.next(),this.parseFunctionStatement(n,!0);var a=this.value,o=this.parseExpression();return r===V.name&&"Identifier"===o.type&&this.eat(V.colon)?this.parseLabeledStatement(n,a,o):this.parseExpressionStatement(n,o)}},X.parseBreakContinueStatement=function(t,e){var s=this,i="break"==e;this.next(),this.eat(V.semi)||this.insertSemicolon()?t.label=null:this.type!==V.name?this.unexpected():(t.label=this.parseIdent(),this.semicolon());for(var r=0;r<this.labels.length;++r){var n=s.labels[r];if(null==t.label||n.name===t.label.name){if(null!=n.kind&&(i||"loop"===n.kind))break;if(t.label&&i)break}}return r===this.labels.length&&this.raise(t.start,"Unsyntactic "+e),this.finishNode(t,i?"BreakStatement":"ContinueStatement")},X.parseDebuggerStatement=function(t){return this.next(),this.semicolon(),this.finishNode(t,"DebuggerStatement")},X.parseDoStatement=function(t){return this.next(),this.labels.push(K),t.body=this.parseStatement(!1),this.labels.pop(),this.expect(V._while),t.test=this.parseParenExpression(),this.options.ecmaVersion>=6?this.eat(V.semi):this.semicolon(),this.finishNode(t,"DoWhileStatement")},X.parseForStatement=function(t){if(this.next(),this.labels.push(K),this.enterLexicalScope(),this.expect(V.parenL),this.type===V.semi)return this.parseFor(t,null);var e=this.isLet();if(this.type===V._var||this.type===V._const||e){var s=this.startNode(),i=e?"let":this.value;return this.next(),this.parseVar(s,!0,i),this.finishNode(s,"VariableDeclaration"),!(this.type===V._in||this.options.ecmaVersion>=6&&this.isContextual("of"))||1!==s.declarations.length||"var"!==i&&s.declarations[0].init?this.parseFor(t,s):this.parseForIn(t,s)}var r=new u,n=this.parseExpression(!0,r);return this.type===V._in||this.options.ecmaVersion>=6&&this.isContextual("of")?(this.toAssignable(n,!1,r),this.checkLVal(n),this.parseForIn(t,n)):(this.checkExpressionErrors(r,!0),this.parseFor(t,n))},X.parseFunctionStatement=function(t,e){return this.next(),this.parseFunction(t,!0,!1,e)},X.parseIfStatement=function(t){return this.next(),t.test=this.parseParenExpression(),t.consequent=this.parseStatement(!this.strict&&this.type==V._function),t.alternate=this.eat(V._else)?this.parseStatement(!this.strict&&this.type==V._function):null,this.finishNode(t,"IfStatement")},X.parseReturnStatement=function(t){return this.inFunction||this.options.allowReturnOutsideFunction||this.raise(this.start,"'return' outside of function"),this.next(),this.eat(V.semi)||this.insertSemicolon()?t.argument=null:(t.argument=this.parseExpression(),this.semicolon()),this.finishNode(t,"ReturnStatement")},X.parseSwitchStatement=function(t){var e=this;this.next(),t.discriminant=this.parseParenExpression(),t.cases=[],this.expect(V.braceL),this.labels.push(J),this.enterLexicalScope();for(var s,i=!1;this.type!=V.braceR;)if(e.type===V._case||e.type===V._default){var r=e.type===V._case;s&&e.finishNode(s,"SwitchCase"),t.cases.push(s=e.startNode()),s.consequent=[],e.next(),r?s.test=e.parseExpression():(i&&e.raiseRecoverable(e.lastTokStart,"Multiple default clauses"),i=!0,s.test=null),e.expect(V.colon)}else s||e.unexpected(),s.consequent.push(e.parseStatement(!0));return this.exitLexicalScope(),s&&this.finishNode(s,"SwitchCase"),this.next(),this.labels.pop(),this.finishNode(t,"SwitchStatement")},X.parseThrowStatement=function(t){return this.next(),F.test(this.input.slice(this.lastTokEnd,this.start))&&this.raise(this.lastTokEnd,"Illegal newline after throw"),t.argument=this.parseExpression(),this.semicolon(),this.finishNode(t,"ThrowStatement")};var Z=[];X.parseTryStatement=function(t){if(this.next(),t.block=this.parseBlock(),t.handler=null,this.type===V._catch){var e=this.startNode();this.next(),this.expect(V.parenL),e.param=this.parseBindingAtom(),this.enterLexicalScope(),this.checkLVal(e.param,"let"),this.expect(V.parenR),e.body=this.parseBlock(!1),this.exitLexicalScope(),t.handler=this.finishNode(e,"CatchClause")}return t.finalizer=this.eat(V._finally)?this.parseBlock():null,t.handler||t.finalizer||this.raise(t.start,"Missing catch or finally clause"),this.finishNode(t,"TryStatement")},X.parseVarStatement=function(t,e){return this.next(),this.parseVar(t,!1,e),this.semicolon(),this.finishNode(t,"VariableDeclaration")},X.parseWhileStatement=function(t){return this.next(),t.test=this.parseParenExpression(),this.labels.push(K),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"WhileStatement")},X.parseWithStatement=function(t){return this.strict&&this.raise(this.start,"'with' in strict mode"),this.next(),t.object=this.parseParenExpression(),t.body=this.parseStatement(!1),this.finishNode(t,"WithStatement")},X.parseEmptyStatement=function(t){return this.next(),this.finishNode(t,"EmptyStatement")},X.parseLabeledStatement=function(t,e,s){for(var i=this,r=0,n=i.labels;r<n.length;r+=1){n[r].name===e&&i.raise(s.start,"Label '"+e+"' is already declared")}for(var a=this.type.isLoop?"loop":this.type===V._switch?"switch":null,o=this.labels.length-1;o>=0;o--){var h=i.labels[o];if(h.statementStart!=t.start)break;h.statementStart=i.start,h.kind=a}return this.labels.push({name:e,kind:a,statementStart:this.start}),t.body=this.parseStatement(!0),("ClassDeclaration"==t.body.type||"VariableDeclaration"==t.body.type&&"var"!=t.body.kind||"FunctionDeclaration"==t.body.type&&(this.strict||t.body.generator))&&this.raiseRecoverable(t.body.start,"Invalid labeled declaration"),this.labels.pop(),t.label=s,this.finishNode(t,"LabeledStatement")},X.parseExpressionStatement=function(t,e){return t.expression=e,this.semicolon(),this.finishNode(t,"ExpressionStatement")},X.parseBlock=function(t){var e=this;void 0===t&&(t=!0);var s=this.startNode();for(s.body=[],this.expect(V.braceL),t&&this.enterLexicalScope();!this.eat(V.braceR);){var i=e.parseStatement(!0);s.body.push(i)}return t&&this.exitLexicalScope(),this.finishNode(s,"BlockStatement")},X.parseFor=function(t,e){return t.init=e,this.expect(V.semi),t.test=this.type===V.semi?null:this.parseExpression(),this.expect(V.semi),t.update=this.type===V.parenR?null:this.parseExpression(),this.expect(V.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"ForStatement")},X.parseForIn=function(t,e){var s=this.type===V._in?"ForInStatement":"ForOfStatement";return this.next(),"ForInStatement"==s&&("AssignmentPattern"===e.type||"VariableDeclaration"===e.type&&null!=e.declarations[0].init&&(this.strict||"Identifier"!==e.declarations[0].id.type))&&this.raise(e.start,"Invalid assignment in for-in loop head"),t.left=e,t.right="ForInStatement"==s?this.parseExpression():this.parseMaybeAssign(),this.expect(V.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,s)},X.parseVar=function(t,e,s){var i=this;for(t.declarations=[],t.kind=s;;){var r=i.startNode();if(i.parseVarId(r,s),i.eat(V.eq)?r.init=i.parseMaybeAssign(e):"const"!==s||i.type===V._in||i.options.ecmaVersion>=6&&i.isContextual("of")?"Identifier"==r.id.type||e&&(i.type===V._in||i.isContextual("of"))?r.init=null:i.raise(i.lastTokEnd,"Complex binding patterns require an initialization value"):i.unexpected(),t.declarations.push(i.finishNode(r,"VariableDeclarator")),!i.eat(V.comma))break}return t},X.parseVarId=function(t,e){t.id=this.parseBindingAtom(e),this.checkLVal(t.id,e,!1)},X.parseFunction=function(t,e,s,i){this.initFunction(t),this.options.ecmaVersion>=6&&!i&&(t.generator=this.eat(V.star)),this.options.ecmaVersion>=8&&(t.async=!!i),e&&(t.id="nullableID"===e&&this.type!=V.name?null:this.parseIdent(),t.id&&this.checkLVal(t.id,"var"));var r=this.inGenerator,n=this.inAsync,a=this.yieldPos,o=this.awaitPos,h=this.inFunction;return this.inGenerator=t.generator,this.inAsync=t.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,this.enterFunctionScope(),e||(t.id=this.type==V.name?this.parseIdent():null),this.parseFunctionParams(t),this.parseFunctionBody(t,s),this.inGenerator=r,this.inAsync=n,this.yieldPos=a,this.awaitPos=o,this.inFunction=h,this.finishNode(t,e?"FunctionDeclaration":"FunctionExpression")},X.parseFunctionParams=function(t){this.expect(V.parenL),t.params=this.parseBindingList(V.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams()},X.parseClass=function(t,e){var s=this;this.next(),this.parseClassId(t,e),this.parseClassSuper(t);var i=this.startNode(),r=!1;for(i.body=[],this.expect(V.braceL);!this.eat(V.braceR);){var n=s.parseClassMember(i);n&&"MethodDefinition"===n.type&&"constructor"===n.kind&&(r&&s.raise(n.start,"Duplicate constructor in the same class"),r=!0)}return t.body=this.finishNode(i,"ClassBody"),this.finishNode(t,e?"ClassDeclaration":"ClassExpression")},X.parseClassMember=function(t){var e=this;if(this.eat(V.semi))return null;var s=this.startNode(),i=function(t,i){void 0===i&&(i=!1);var r=e.start,n=e.startLoc;return!!e.eatContextual(t)&&(!(e.type===V.parenL||i&&e.canInsertSemicolon())||(s.key&&e.unexpected(),s.computed=!1,s.key=e.startNodeAt(r,n),s.key.name=t,e.finishNode(s.key,"Identifier"),!1))};s.kind="method",s.static=i("static");var r=this.eat(V.star),n=!1;r||(this.options.ecmaVersion>=8&&i("async",!0)?n=!0:i("get")?s.kind="get":i("set")&&(s.kind="set")),s.key||this.parsePropertyName(s);var a=s.key;return s.computed||s.static||!("Identifier"===a.type&&"constructor"===a.name||"Literal"===a.type&&"constructor"===a.value)?s.static&&"Identifier"===a.type&&"prototype"===a.name&&this.raise(a.start,"Classes may not have a static property named prototype"):("method"!==s.kind&&this.raise(a.start,"Constructor can't have get/set modifier"),r&&this.raise(a.start,"Constructor can't be a generator"),n&&this.raise(a.start,"Constructor can't be an async method"),s.kind="constructor"),this.parseClassMethod(t,s,r,n),"get"===s.kind&&0!==s.value.params.length&&this.raiseRecoverable(s.value.start,"getter should have no params"),"set"===s.kind&&1!==s.value.params.length&&this.raiseRecoverable(s.value.start,"setter should have exactly one param"),"set"===s.kind&&"RestElement"===s.value.params[0].type&&this.raiseRecoverable(s.value.params[0].start,"Setter cannot use rest params"),s},X.parseClassMethod=function(t,e,s,i){e.value=this.parseMethod(s,i),t.body.push(this.finishNode(e,"MethodDefinition"))},X.parseClassId=function(t,e){t.id=this.type===V.name?this.parseIdent():!0===e?this.unexpected():null},X.parseClassSuper=function(t){t.superClass=this.eat(V._extends)?this.parseExprSubscripts():null},X.parseExport=function(t,e){var s=this;if(this.next(),this.eat(V.star))return this.expectContextual("from"),this.type!==V.string&&this.unexpected(),t.source=this.parseExprAtom(),this.semicolon(),this.finishNode(t,"ExportAllDeclaration");if(this.eat(V._default)){this.checkExport(e,"default",this.lastTokStart);var i;if(this.type===V._function||(i=this.isAsyncFunction())){var r=this.startNode();this.next(),i&&this.next(),t.declaration=this.parseFunction(r,"nullableID",!1,i)}else if(this.type===V._class){var n=this.startNode();t.declaration=this.parseClass(n,"nullableID")}else t.declaration=this.parseMaybeAssign(),this.semicolon();return this.finishNode(t,"ExportDefaultDeclaration")}if(this.shouldParseExportStatement())t.declaration=this.parseStatement(!0),"VariableDeclaration"===t.declaration.type?this.checkVariableExport(e,t.declaration.declarations):this.checkExport(e,t.declaration.id.name,t.declaration.id.start),t.specifiers=[],t.source=null;else{if(t.declaration=null,t.specifiers=this.parseExportSpecifiers(e),this.eatContextual("from"))this.type!==V.string&&this.unexpected(),t.source=this.parseExprAtom();else{for(var a=0,o=t.specifiers;a<o.length;a+=1){var h=o[a];s.checkUnreserved(h.local)}t.source=null}this.semicolon()}return this.finishNode(t,"ExportNamedDeclaration")},X.checkExport=function(t,e,s){t&&(o(t,e)&&this.raiseRecoverable(s,"Duplicate export '"+e+"'"),t[e]=!0)},X.checkPatternExport=function(t,e){var s=this,i=e.type;if("Identifier"==i)this.checkExport(t,e.name,e.start);else if("ObjectPattern"==i)for(var r=0,n=e.properties;r<n.length;r+=1){var a=n[r];s.checkPatternExport(t,a.value)}else if("ArrayPattern"==i)for(var o=0,h=e.elements;o<h.length;o+=1){var p=h[o];p&&s.checkPatternExport(t,p)}else"AssignmentPattern"==i?this.checkPatternExport(t,e.left):"ParenthesizedExpression"==i&&this.checkPatternExport(t,e.expression)},X.checkVariableExport=function(t,e){var s=this;if(t)for(var i=0,r=e;i<r.length;i+=1){var n=r[i];s.checkPatternExport(t,n.id)}},X.shouldParseExportStatement=function(){return"var"===this.type.keyword||"const"===this.type.keyword||"class"===this.type.keyword||"function"===this.type.keyword||this.isLet()||this.isAsyncFunction()},X.parseExportSpecifiers=function(t){var e=this,s=[],i=!0;for(this.expect(V.braceL);!this.eat(V.braceR);){if(i)i=!1;else if(e.expect(V.comma),e.afterTrailingComma(V.braceR))break;var r=e.startNode();r.local=e.parseIdent(!0),r.exported=e.eatContextual("as")?e.parseIdent(!0):r.local,e.checkExport(t,r.exported.name,r.exported.start),s.push(e.finishNode(r,"ExportSpecifier"))}return s},X.parseImport=function(t){return this.next(),this.type===V.string?(t.specifiers=Z,t.source=this.parseExprAtom()):(t.specifiers=this.parseImportSpecifiers(),this.expectContextual("from"),t.source=this.type===V.string?this.parseExprAtom():this.unexpected()),this.semicolon(),this.finishNode(t,"ImportDeclaration")},X.parseImportSpecifiers=function(){var t=this,e=[],s=!0;if(this.type===V.name){var i=this.startNode();if(i.local=this.parseIdent(),this.checkLVal(i.local,"let"),e.push(this.finishNode(i,"ImportDefaultSpecifier")),!this.eat(V.comma))return e}if(this.type===V.star){var r=this.startNode();return this.next(),this.expectContextual("as"),r.local=this.parseIdent(),this.checkLVal(r.local,"let"),e.push(this.finishNode(r,"ImportNamespaceSpecifier")),e}for(this.expect(V.braceL);!this.eat(V.braceR);){if(s)s=!1;else if(t.expect(V.comma),t.afterTrailingComma(V.braceR))break;var n=t.startNode();n.imported=t.parseIdent(!0),t.eatContextual("as")?n.local=t.parseIdent():(t.checkUnreserved(n.imported),n.local=n.imported),t.checkLVal(n.local,"let"),e.push(t.finishNode(n,"ImportSpecifier"))}return e},X.adaptDirectivePrologue=function(t){for(var e=0;e<t.length&&this.isDirectiveCandidate(t[e]);++e)t[e].directive=t[e].expression.raw.slice(1,-1)},X.isDirectiveCandidate=function(t){return"ExpressionStatement"===t.type&&"Literal"===t.expression.type&&"string"==typeof t.expression.value&&('"'===this.input[t.start]||"'"===this.input[t.start])};var tt=$.prototype;tt.toAssignable=function(t,e,s){var i=this;if(this.options.ecmaVersion>=6&&t)switch(t.type){case"Identifier":this.inAsync&&"await"===t.name&&this.raise(t.start,"Can not use 'await' as identifier inside an async function");break;case"ObjectPattern":case"ArrayPattern":case"RestElement":break;case"ObjectExpression":t.type="ObjectPattern",s&&this.checkPatternErrors(s,!0);for(var r=0,n=t.properties;r<n.length;r+=1){var a=n[r];i.toAssignable(a,e)}break;case"Property":"init"!==t.kind&&this.raise(t.key.start,"Object pattern can't contain getter or setter"),this.toAssignable(t.value,e);break;case"ArrayExpression":t.type="ArrayPattern",s&&this.checkPatternErrors(s,!0),this.toAssignableList(t.elements,e);break;case"SpreadElement":t.type="RestElement",this.toAssignable(t.argument,e),"AssignmentPattern"===t.argument.type&&this.raise(t.argument.start,"Rest elements cannot have a default value");break;case"AssignmentExpression":"="!==t.operator&&this.raise(t.left.end,"Only '=' operator can be used for specifying default value."),t.type="AssignmentPattern",delete t.operator,this.toAssignable(t.left,e);case"AssignmentPattern":break;case"ParenthesizedExpression":this.toAssignable(t.expression,e);break;case"MemberExpression":if(!e)break;default:this.raise(t.start,"Assigning to rvalue")}else s&&this.checkPatternErrors(s,!0);return t},tt.toAssignableList=function(t,e){for(var s=this,i=t.length,r=0;r<i;r++){var n=t[r];n&&s.toAssignable(n,e)}if(i){var a=t[i-1];6===this.options.ecmaVersion&&e&&a&&"RestElement"===a.type&&"Identifier"!==a.argument.type&&this.unexpected(a.argument.start)}return t},tt.parseSpread=function(t){var e=this.startNode();return this.next(),e.argument=this.parseMaybeAssign(!1,t),this.finishNode(e,"SpreadElement")},tt.parseRestBinding=function(){var t=this.startNode();return this.next(),6===this.options.ecmaVersion&&this.type!==V.name&&this.unexpected(),t.argument=this.parseBindingAtom(),this.finishNode(t,"RestElement")},tt.parseBindingAtom=function(){if(this.options.ecmaVersion>=6)switch(this.type){case V.bracketL:var t=this.startNode();return this.next(),t.elements=this.parseBindingList(V.bracketR,!0,!0),this.finishNode(t,"ArrayPattern");case V.braceL:return this.parseObj(!0)}return this.parseIdent()},tt.parseBindingList=function(t,e,s){
-for(var i=this,r=[],n=!0;!this.eat(t);)if(n?n=!1:i.expect(V.comma),e&&i.type===V.comma)r.push(null);else{if(s&&i.afterTrailingComma(t))break;if(i.type===V.ellipsis){var a=i.parseRestBinding();i.parseBindingListItem(a),r.push(a),i.type===V.comma&&i.raise(i.start,"Comma is not permitted after the rest element"),i.expect(t);break}var o=i.parseMaybeDefault(i.start,i.startLoc);i.parseBindingListItem(o),r.push(o)}return r},tt.parseBindingListItem=function(t){return t},tt.parseMaybeDefault=function(t,e,s){if(s=s||this.parseBindingAtom(),this.options.ecmaVersion<6||!this.eat(V.eq))return s;var i=this.startNodeAt(t,e);return i.left=s,i.right=this.parseMaybeAssign(),this.finishNode(i,"AssignmentPattern")},tt.checkLVal=function(t,e,s){var i=this;switch(t.type){case"Identifier":this.strict&&this.reservedWordsStrictBind.test(t.name)&&this.raiseRecoverable(t.start,(e?"Binding ":"Assigning to ")+t.name+" in strict mode"),s&&(o(s,t.name)&&this.raiseRecoverable(t.start,"Argument name clash"),s[t.name]=!0),e&&"none"!==e&&(("var"===e&&!this.canDeclareVarName(t.name)||"var"!==e&&!this.canDeclareLexicalName(t.name))&&this.raiseRecoverable(t.start,"Identifier '"+t.name+"' has already been declared"),"var"===e?this.declareVarName(t.name):this.declareLexicalName(t.name));break;case"MemberExpression":e&&this.raiseRecoverable(t.start,"Binding member expression");break;case"ObjectPattern":for(var r=0,n=t.properties;r<n.length;r+=1){var a=n[r];i.checkLVal(a,e,s)}break;case"Property":this.checkLVal(t.value,e,s);break;case"ArrayPattern":for(var h=0,p=t.elements;h<p.length;h+=1){var c=p[h];c&&i.checkLVal(c,e,s)}break;case"AssignmentPattern":this.checkLVal(t.left,e,s);break;case"RestElement":this.checkLVal(t.argument,e,s);break;case"ParenthesizedExpression":this.checkLVal(t.expression,e,s);break;default:this.raise(t.start,(e?"Binding":"Assigning to")+" rvalue")}};var et=$.prototype;et.checkPropClash=function(t,e,s){if(!(this.options.ecmaVersion>=6&&(t.computed||t.method||t.shorthand))){var i,r=t.key;switch(r.type){case"Identifier":i=r.name;break;case"Literal":i=String(r.value);break;default:return}var n=t.kind;if(this.options.ecmaVersion>=6)return void("__proto__"===i&&"init"===n&&(e.proto&&(s&&s.doubleProto<0?s.doubleProto=r.start:this.raiseRecoverable(r.start,"Redefinition of __proto__ property")),e.proto=!0));i="$"+i;var a=e[i];if(a){var o;o="init"===n?this.strict&&a.init||a.get||a.set:a.init||a[n],o&&this.raiseRecoverable(r.start,"Redefinition of property")}else a=e[i]={init:!1,get:!1,set:!1};a[n]=!0}},et.parseExpression=function(t,e){var s=this,i=this.start,r=this.startLoc,n=this.parseMaybeAssign(t,e);if(this.type===V.comma){var a=this.startNodeAt(i,r);for(a.expressions=[n];this.eat(V.comma);)a.expressions.push(s.parseMaybeAssign(t,e));return this.finishNode(a,"SequenceExpression")}return n},et.parseMaybeAssign=function(t,e,s){if(this.inGenerator&&this.isContextual("yield"))return this.parseYield();var i=!1,r=-1,n=-1;e?(r=e.parenthesizedAssign,n=e.trailingComma,e.parenthesizedAssign=e.trailingComma=-1):(e=new u,i=!0);var a=this.start,o=this.startLoc;this.type!=V.parenL&&this.type!=V.name||(this.potentialArrowAt=this.start);var h=this.parseMaybeConditional(t,e);if(s&&(h=s.call(this,h,a,o)),this.type.isAssign){var p=this.startNodeAt(a,o);return p.operator=this.value,p.left=this.type===V.eq?this.toAssignable(h,!1,e):h,i||u.call(e),e.shorthandAssign=-1,this.checkLVal(h),this.next(),p.right=this.parseMaybeAssign(t),this.finishNode(p,"AssignmentExpression")}return i&&this.checkExpressionErrors(e,!0),r>-1&&(e.parenthesizedAssign=r),n>-1&&(e.trailingComma=n),h},et.parseMaybeConditional=function(t,e){var s=this.start,i=this.startLoc,r=this.parseExprOps(t,e);if(this.checkExpressionErrors(e))return r;if(this.eat(V.question)){var n=this.startNodeAt(s,i);return n.test=r,n.consequent=this.parseMaybeAssign(),this.expect(V.colon),n.alternate=this.parseMaybeAssign(t),this.finishNode(n,"ConditionalExpression")}return r},et.parseExprOps=function(t,e){var s=this.start,i=this.startLoc,r=this.parseMaybeUnary(e,!1);return this.checkExpressionErrors(e)?r:r.start==s&&"ArrowFunctionExpression"===r.type?r:this.parseExprOp(r,s,i,-1,t)},et.parseExprOp=function(t,e,s,i,r){var n=this.type.binop;if(null!=n&&(!r||this.type!==V._in)&&n>i){var a=this.type===V.logicalOR||this.type===V.logicalAND,o=this.value;this.next();var h=this.start,p=this.startLoc,c=this.parseExprOp(this.parseMaybeUnary(null,!1),h,p,n,r),l=this.buildBinary(e,s,t,c,o,a);return this.parseExprOp(l,e,s,i,r)}return t},et.buildBinary=function(t,e,s,i,r,n){var a=this.startNodeAt(t,e);return a.left=s,a.operator=r,a.right=i,this.finishNode(a,n?"LogicalExpression":"BinaryExpression")},et.parseMaybeUnary=function(t,e){var s,i=this,r=this.start,n=this.startLoc;if(this.inAsync&&this.isContextual("await"))s=this.parseAwait(),e=!0;else if(this.type.prefix){var a=this.startNode(),o=this.type===V.incDec;a.operator=this.value,a.prefix=!0,this.next(),a.argument=this.parseMaybeUnary(null,!0),this.checkExpressionErrors(t,!0),o?this.checkLVal(a.argument):this.strict&&"delete"===a.operator&&"Identifier"===a.argument.type?this.raiseRecoverable(a.start,"Deleting local variable in strict mode"):e=!0,s=this.finishNode(a,o?"UpdateExpression":"UnaryExpression")}else{if(s=this.parseExprSubscripts(t),this.checkExpressionErrors(t))return s;for(;this.type.postfix&&!this.canInsertSemicolon();){var h=i.startNodeAt(r,n);h.operator=i.value,h.prefix=!1,h.argument=s,i.checkLVal(s),i.next(),s=i.finishNode(h,"UpdateExpression")}}return!e&&this.eat(V.starstar)?this.buildBinary(r,n,s,this.parseMaybeUnary(null,!1),"**",!1):s},et.parseExprSubscripts=function(t){var e=this.start,s=this.startLoc,i=this.parseExprAtom(t),r="ArrowFunctionExpression"===i.type&&")"!==this.input.slice(this.lastTokStart,this.lastTokEnd);if(this.checkExpressionErrors(t)||r)return i;var n=this.parseSubscripts(i,e,s);return t&&"MemberExpression"===n.type&&(t.parenthesizedAssign>=n.start&&(t.parenthesizedAssign=-1),t.parenthesizedBind>=n.start&&(t.parenthesizedBind=-1)),n},et.parseSubscripts=function(t,e,s,i){for(var r=this,n=this.options.ecmaVersion>=8&&"Identifier"===t.type&&"async"===t.name&&this.lastTokEnd==t.end&&!this.canInsertSemicolon()&&"async"===this.input.slice(t.start,t.end),a=void 0;;)if((a=r.eat(V.bracketL))||r.eat(V.dot)){var o=r.startNodeAt(e,s);o.object=t,o.property=a?r.parseExpression():r.parseIdent(!0),o.computed=!!a,a&&r.expect(V.bracketR),t=r.finishNode(o,"MemberExpression")}else if(!i&&r.eat(V.parenL)){var h=new u,p=r.yieldPos,c=r.awaitPos;r.yieldPos=0,r.awaitPos=0;var l=r.parseExprList(V.parenR,r.options.ecmaVersion>=8,!1,h);if(n&&!r.canInsertSemicolon()&&r.eat(V.arrow))return r.checkPatternErrors(h,!1),r.checkYieldAwaitInDefaultParams(),r.yieldPos=p,r.awaitPos=c,r.parseArrowExpression(r.startNodeAt(e,s),l,!0);r.checkExpressionErrors(h,!0),r.yieldPos=p||r.yieldPos,r.awaitPos=c||r.awaitPos;var d=r.startNodeAt(e,s);d.callee=t,d.arguments=l,t=r.finishNode(d,"CallExpression")}else{if(r.type!==V.backQuote)return t;var f=r.startNodeAt(e,s);f.tag=t,f.quasi=r.parseTemplate({isTagged:!0}),t=r.finishNode(f,"TaggedTemplateExpression")}},et.parseExprAtom=function(t){var e,s=this.potentialArrowAt==this.start;switch(this.type){case V._super:return this.inFunction||this.raise(this.start,"'super' outside of function or class"),e=this.startNode(),this.next(),this.type!==V.dot&&this.type!==V.bracketL&&this.type!==V.parenL&&this.unexpected(),this.finishNode(e,"Super");case V._this:return e=this.startNode(),this.next(),this.finishNode(e,"ThisExpression");case V.name:var i=this.start,r=this.startLoc,n=this.containsEsc,a=this.parseIdent(this.type!==V.name);if(this.options.ecmaVersion>=8&&!n&&"async"===a.name&&!this.canInsertSemicolon()&&this.eat(V._function))return this.parseFunction(this.startNodeAt(i,r),!1,!1,!0);if(s&&!this.canInsertSemicolon()){if(this.eat(V.arrow))return this.parseArrowExpression(this.startNodeAt(i,r),[a],!1);if(this.options.ecmaVersion>=8&&"async"===a.name&&this.type===V.name&&!n)return a=this.parseIdent(),!this.canInsertSemicolon()&&this.eat(V.arrow)||this.unexpected(),this.parseArrowExpression(this.startNodeAt(i,r),[a],!0)}return a;case V.regexp:var o=this.value;return e=this.parseLiteral(o.value),e.regex={pattern:o.pattern,flags:o.flags},e;case V.num:case V.string:return this.parseLiteral(this.value);case V._null:case V._true:case V._false:return e=this.startNode(),e.value=this.type===V._null?null:this.type===V._true,e.raw=this.type.keyword,this.next(),this.finishNode(e,"Literal");case V.parenL:var h=this.start,p=this.parseParenAndDistinguishExpression(s);return t&&(t.parenthesizedAssign<0&&!this.isSimpleAssignTarget(p)&&(t.parenthesizedAssign=h),t.parenthesizedBind<0&&(t.parenthesizedBind=h)),p;case V.bracketL:return e=this.startNode(),this.next(),e.elements=this.parseExprList(V.bracketR,!0,!0,t),this.finishNode(e,"ArrayExpression");case V.braceL:return this.parseObj(!1,t);case V._function:return e=this.startNode(),this.next(),this.parseFunction(e,!1);case V._class:return this.parseClass(this.startNode(),!1);case V._new:return this.parseNew();case V.backQuote:return this.parseTemplate();default:this.unexpected()}},et.parseLiteral=function(t){var e=this.startNode();return e.value=t,e.raw=this.input.slice(this.start,this.end),this.next(),this.finishNode(e,"Literal")},et.parseParenExpression=function(){this.expect(V.parenL);var t=this.parseExpression();return this.expect(V.parenR),t},et.parseParenAndDistinguishExpression=function(t){var e,s=this,i=this.start,r=this.startLoc,n=this.options.ecmaVersion>=8;if(this.options.ecmaVersion>=6){this.next();var a,o=this.start,h=this.startLoc,p=[],c=!0,l=!1,d=new u,f=this.yieldPos,m=this.awaitPos;for(this.yieldPos=0,this.awaitPos=0;this.type!==V.parenR;){if(c?c=!1:s.expect(V.comma),n&&s.afterTrailingComma(V.parenR,!0)){l=!0;break}if(s.type===V.ellipsis){a=s.start,p.push(s.parseParenItem(s.parseRestBinding())),s.type===V.comma&&s.raise(s.start,"Comma is not permitted after the rest element");break}p.push(s.parseMaybeAssign(!1,d,s.parseParenItem))}var x=this.start,y=this.startLoc;if(this.expect(V.parenR),t&&!this.canInsertSemicolon()&&this.eat(V.arrow))return this.checkPatternErrors(d,!1),this.checkYieldAwaitInDefaultParams(),this.yieldPos=f,this.awaitPos=m,this.parseParenArrowList(i,r,p);p.length&&!l||this.unexpected(this.lastTokStart),a&&this.unexpected(a),this.checkExpressionErrors(d,!0),this.yieldPos=f||this.yieldPos,this.awaitPos=m||this.awaitPos,p.length>1?(e=this.startNodeAt(o,h),e.expressions=p,this.finishNodeAt(e,"SequenceExpression",x,y)):e=p[0]}else e=this.parseParenExpression();if(this.options.preserveParens){var v=this.startNodeAt(i,r);return v.expression=e,this.finishNode(v,"ParenthesizedExpression")}return e},et.parseParenItem=function(t){return t},et.parseParenArrowList=function(t,e,s){return this.parseArrowExpression(this.startNodeAt(t,e),s)};var st=[];et.parseNew=function(){var t=this.startNode(),e=this.parseIdent(!0);if(this.options.ecmaVersion>=6&&this.eat(V.dot)){t.meta=e;var s=this.containsEsc;return t.property=this.parseIdent(!0),("target"!==t.property.name||s)&&this.raiseRecoverable(t.property.start,"The only valid meta property for new is new.target"),this.inFunction||this.raiseRecoverable(t.start,"new.target can only be used in functions"),this.finishNode(t,"MetaProperty")}var i=this.start,r=this.startLoc;return t.callee=this.parseSubscripts(this.parseExprAtom(),i,r,!0),this.eat(V.parenL)?t.arguments=this.parseExprList(V.parenR,this.options.ecmaVersion>=8,!1):t.arguments=st,this.finishNode(t,"NewExpression")},et.parseTemplateElement=function(t){var e=t.isTagged,s=this.startNode();return this.type===V.invalidTemplate?(e||this.raiseRecoverable(this.start,"Bad escape sequence in untagged template literal"),s.value={raw:this.value,cooked:null}):s.value={raw:this.input.slice(this.start,this.end).replace(/\r\n?/g,"\n"),cooked:this.value},this.next(),s.tail=this.type===V.backQuote,this.finishNode(s,"TemplateElement")},et.parseTemplate=function(t){var e=this;void 0===t&&(t={});var s=t.isTagged;void 0===s&&(s=!1);var i=this.startNode();this.next(),i.expressions=[];var r=this.parseTemplateElement({isTagged:s});for(i.quasis=[r];!r.tail;)e.expect(V.dollarBraceL),i.expressions.push(e.parseExpression()),e.expect(V.braceR),i.quasis.push(r=e.parseTemplateElement({isTagged:s}));return this.next(),this.finishNode(i,"TemplateLiteral")},et.isAsyncProp=function(t){return!t.computed&&"Identifier"===t.key.type&&"async"===t.key.name&&(this.type===V.name||this.type===V.num||this.type===V.string||this.type===V.bracketL||this.type.keyword)&&!F.test(this.input.slice(this.lastTokEnd,this.start))},et.parseObj=function(t,e){var s=this,i=this.startNode(),r=!0,n={};for(i.properties=[],this.next();!this.eat(V.braceR);){if(r)r=!1;else if(s.expect(V.comma),s.afterTrailingComma(V.braceR))break;var a=s.parseProperty(t,e);t||s.checkPropClash(a,n,e),i.properties.push(a)}return this.finishNode(i,t?"ObjectPattern":"ObjectExpression")},et.parseProperty=function(t,e){var s,i,r,n,a=this.startNode();this.options.ecmaVersion>=6&&(a.method=!1,a.shorthand=!1,(t||e)&&(r=this.start,n=this.startLoc),t||(s=this.eat(V.star)));var o=this.containsEsc;return this.parsePropertyName(a),!t&&!o&&this.options.ecmaVersion>=8&&!s&&this.isAsyncProp(a)?(i=!0,this.parsePropertyName(a,e)):i=!1,this.parsePropertyValue(a,t,s,i,r,n,e,o),this.finishNode(a,"Property")},et.parsePropertyValue=function(t,e,s,i,r,n,a,o){if((s||i)&&this.type===V.colon&&this.unexpected(),this.eat(V.colon))t.value=e?this.parseMaybeDefault(this.start,this.startLoc):this.parseMaybeAssign(!1,a),t.kind="init";else if(this.options.ecmaVersion>=6&&this.type===V.parenL)e&&this.unexpected(),t.kind="init",t.method=!0,t.value=this.parseMethod(s,i);else if(e||o||!(this.options.ecmaVersion>=5)||t.computed||"Identifier"!==t.key.type||"get"!==t.key.name&&"set"!==t.key.name||this.type==V.comma||this.type==V.braceR)this.options.ecmaVersion>=6&&!t.computed&&"Identifier"===t.key.type?(this.checkUnreserved(t.key),t.kind="init",e?t.value=this.parseMaybeDefault(r,n,t.key):this.type===V.eq&&a?(a.shorthandAssign<0&&(a.shorthandAssign=this.start),t.value=this.parseMaybeDefault(r,n,t.key)):t.value=t.key,t.shorthand=!0):this.unexpected();else{(s||i)&&this.unexpected(),t.kind=t.key.name,this.parsePropertyName(t),t.value=this.parseMethod(!1);var h="get"===t.kind?0:1;if(t.value.params.length!==h){var p=t.value.start;"get"===t.kind?this.raiseRecoverable(p,"getter should have no params"):this.raiseRecoverable(p,"setter should have exactly one param")}else"set"===t.kind&&"RestElement"===t.value.params[0].type&&this.raiseRecoverable(t.value.params[0].start,"Setter cannot use rest params")}},et.parsePropertyName=function(t){if(this.options.ecmaVersion>=6){if(this.eat(V.bracketL))return t.computed=!0,t.key=this.parseMaybeAssign(),this.expect(V.bracketR),t.key;t.computed=!1}return t.key=this.type===V.num||this.type===V.string?this.parseExprAtom():this.parseIdent(!0)},et.initFunction=function(t){t.id=null,this.options.ecmaVersion>=6&&(t.generator=!1,t.expression=!1),this.options.ecmaVersion>=8&&(t.async=!1)},et.parseMethod=function(t,e){var s=this.startNode(),i=this.inGenerator,r=this.inAsync,n=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.initFunction(s),this.options.ecmaVersion>=6&&(s.generator=t),this.options.ecmaVersion>=8&&(s.async=!!e),this.inGenerator=s.generator,this.inAsync=s.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,this.enterFunctionScope(),this.expect(V.parenL),s.params=this.parseBindingList(V.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams(),this.parseFunctionBody(s,!1),this.inGenerator=i,this.inAsync=r,this.yieldPos=n,this.awaitPos=a,this.inFunction=o,this.finishNode(s,"FunctionExpression")},et.parseArrowExpression=function(t,e,s){var i=this.inGenerator,r=this.inAsync,n=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.enterFunctionScope(),this.initFunction(t),this.options.ecmaVersion>=8&&(t.async=!!s),this.inGenerator=!1,this.inAsync=t.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,t.params=this.toAssignableList(e,!0),this.parseFunctionBody(t,!0),this.inGenerator=i,this.inAsync=r,this.yieldPos=n,this.awaitPos=a,this.inFunction=o,this.finishNode(t,"ArrowFunctionExpression")},et.parseFunctionBody=function(t,e){var s=e&&this.type!==V.braceL,i=this.strict,r=!1;if(s)t.body=this.parseMaybeAssign(),t.expression=!0,this.checkParams(t,!1);else{var n=this.options.ecmaVersion>=7&&!this.isSimpleParamList(t.params);i&&!n||(r=this.strictDirective(this.end))&&n&&this.raiseRecoverable(t.start,"Illegal 'use strict' directive in function with non-simple parameter list");var a=this.labels;this.labels=[],r&&(this.strict=!0),this.checkParams(t,!i&&!r&&!e&&this.isSimpleParamList(t.params)),t.body=this.parseBlock(!1),t.expression=!1,this.adaptDirectivePrologue(t.body.body),this.labels=a}this.exitFunctionScope(),this.strict&&t.id&&this.checkLVal(t.id,"none"),this.strict=i},et.isSimpleParamList=function(t){for(var e=0,s=t;e<s.length;e+=1){if("Identifier"!==s[e].type)return!1}return!0},et.checkParams=function(t,e){for(var s=this,i={},r=0,n=t.params;r<n.length;r+=1){var a=n[r];s.checkLVal(a,"var",e?null:i)}},et.parseExprList=function(t,e,s,i){for(var r=this,n=[],a=!0;!this.eat(t);){if(a)a=!1;else if(r.expect(V.comma),e&&r.afterTrailingComma(t))break;var o=void 0;s&&r.type===V.comma?o=null:r.type===V.ellipsis?(o=r.parseSpread(i),i&&r.type===V.comma&&i.trailingComma<0&&(i.trailingComma=r.start)):o=r.parseMaybeAssign(!1,i),n.push(o)}return n},et.checkUnreserved=function(t){var e=t.start,s=t.end,i=t.name;if(this.inGenerator&&"yield"===i&&this.raiseRecoverable(e,"Can not use 'yield' as identifier inside a generator"),this.inAsync&&"await"===i&&this.raiseRecoverable(e,"Can not use 'await' as identifier inside an async function"),this.isKeyword(i)&&this.raise(e,"Unexpected keyword '"+i+"'"),!(this.options.ecmaVersion<6&&-1!=this.input.slice(e,s).indexOf("\\"))){(this.strict?this.reservedWordsStrict:this.reservedWords).test(i)&&(this.inAsync||"await"!==i||this.raiseRecoverable(e,"Can not use keyword 'await' outside an async function"),this.raiseRecoverable(e,"The keyword '"+i+"' is reserved"))}},et.parseIdent=function(t,e){var s=this.startNode();return t&&"never"==this.options.allowReserved&&(t=!1),this.type===V.name?s.name=this.value:this.type.keyword?(s.name=this.type.keyword,"class"!==s.name&&"function"!==s.name||this.lastTokEnd===this.lastTokStart+1&&46===this.input.charCodeAt(this.lastTokStart)||this.context.pop()):this.unexpected(),this.next(),this.finishNode(s,"Identifier"),t||this.checkUnreserved(s),s},et.parseYield=function(){this.yieldPos||(this.yieldPos=this.start);var t=this.startNode();return this.next(),this.type==V.semi||this.canInsertSemicolon()||this.type!=V.star&&!this.type.startsExpr?(t.delegate=!1,t.argument=null):(t.delegate=this.eat(V.star),t.argument=this.parseMaybeAssign()),this.finishNode(t,"YieldExpression")},et.parseAwait=function(){this.awaitPos||(this.awaitPos=this.start);var t=this.startNode();return this.next(),t.argument=this.parseMaybeUnary(null,!0),this.finishNode(t,"AwaitExpression")};var it=$.prototype;it.raise=function(t,e){var s=h(this.input,t);e+=" ("+s.line+":"+s.column+")";var i=new SyntaxError(e);throw i.pos=t,i.loc=s,i.raisedAt=this.pos,i},it.raiseRecoverable=it.raise,it.curPosition=function(){if(this.options.locations)return new j(this.curLine,this.pos-this.lineStart)};var rt=$.prototype,nt=Object.assign||function(t){for(var e=[],s=arguments.length-1;s-- >0;)e[s]=arguments[s+1];for(var i=0,r=e;i<r.length;i+=1){var n=r[i];for(var a in n)o(n,a)&&(t[a]=n[a])}return t};rt.enterFunctionScope=function(){this.scopeStack.push({var:{},lexical:{},childVar:{},parentLexical:{}})},rt.exitFunctionScope=function(){this.scopeStack.pop()},rt.enterLexicalScope=function(){var t=this.scopeStack[this.scopeStack.length-1],e={var:{},lexical:{},childVar:{},parentLexical:{}};this.scopeStack.push(e),nt(e.parentLexical,t.lexical,t.parentLexical)},rt.exitLexicalScope=function(){var t=this.scopeStack.pop(),e=this.scopeStack[this.scopeStack.length-1];nt(e.childVar,t.var,t.childVar)},rt.canDeclareVarName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e.parentLexical,t)},rt.canDeclareLexicalName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e.var,t)&&!o(e.childVar,t)},rt.declareVarName=function(t){this.scopeStack[this.scopeStack.length-1].var[t]=!0},rt.declareLexicalName=function(t){this.scopeStack[this.scopeStack.length-1].lexical[t]=!0};var at=function(t,e,s){this.type="",this.start=e,this.end=0,t.options.locations&&(this.loc=new W(t,s)),t.options.directSourceFile&&(this.sourceFile=t.options.directSourceFile),t.options.ranges&&(this.range=[e,0])},ot=$.prototype;ot.startNode=function(){return new at(this,this.start,this.startLoc)},ot.startNodeAt=function(t,e){return new at(this,t,e)},ot.finishNode=function(t,e){return d.call(this,t,e,this.lastTokEnd,this.lastTokEndLoc)},ot.finishNodeAt=function(t,e,s,i){return d.call(this,t,e,s,i)};var ht=function(t,e,s,i,r){this.token=t,this.isExpr=!!e,this.preserveSpace=!!s,this.override=i,this.generator=!!r},pt={b_stat:new ht("{",!1),b_expr:new ht("{",!0),b_tmpl:new ht("${",!1),p_stat:new ht("(",!1),p_expr:new ht("(",!0),q_tmpl:new ht("`",!0,!0,function(t){return t.tryReadTemplateToken()}),f_stat:new ht("function",!1),f_expr:new ht("function",!0),f_expr_gen:new ht("function",!0,!1,null,!0),f_gen:new ht("function",!1,!1,null,!0)},ct=$.prototype;ct.initialContext=function(){return[pt.b_stat]},ct.braceIsBlock=function(t){var e=this.curContext();return e===pt.f_expr||e===pt.f_stat||(t!==V.colon||e!==pt.b_stat&&e!==pt.b_expr?t===V._return||t==V.name&&this.exprAllowed?F.test(this.input.slice(this.lastTokEnd,this.start)):t===V._else||t===V.semi||t===V.eof||t===V.parenR||t==V.arrow||(t==V.braceL?e===pt.b_stat:t!=V._var&&t!=V.name&&!this.exprAllowed):!e.isExpr)},ct.inGeneratorContext=function(){for(var t=this,e=this.context.length-1;e>=1;e--){var s=t.context[e];if("function"===s.token)return s.generator}return!1},ct.updateContext=function(t){var e,s=this.type;s.keyword&&t==V.dot?this.exprAllowed=!1:(e=s.updateContext)?e.call(this,t):this.exprAllowed=s.beforeExpr},V.parenR.updateContext=V.braceR.updateContext=function(){if(1==this.context.length)return void(this.exprAllowed=!0);var t=this.context.pop();t===pt.b_stat&&"function"===this.curContext().token&&(t=this.context.pop()),this.exprAllowed=!t.isExpr},V.braceL.updateContext=function(t){this.context.push(this.braceIsBlock(t)?pt.b_stat:pt.b_expr),this.exprAllowed=!0},V.dollarBraceL.updateContext=function(){this.context.push(pt.b_tmpl),this.exprAllowed=!0},V.parenL.updateContext=function(t){var e=t===V._if||t===V._for||t===V._with||t===V._while;this.context.push(e?pt.p_stat:pt.p_expr),this.exprAllowed=!0},V.incDec.updateContext=function(){},V._function.updateContext=V._class.updateContext=function(t){t.beforeExpr&&t!==V.semi&&t!==V._else&&(t!==V.colon&&t!==V.braceL||this.curContext()!==pt.b_stat)?this.context.push(pt.f_expr):this.context.push(pt.f_stat),this.exprAllowed=!1},V.backQuote.updateContext=function(){this.curContext()===pt.q_tmpl?this.context.pop():this.context.push(pt.q_tmpl),this.exprAllowed=!1},V.star.updateContext=function(t){if(t==V._function){var e=this.context.length-1;this.context[e]===pt.f_expr?this.context[e]=pt.f_expr_gen:this.context[e]=pt.f_gen}this.exprAllowed=!0},V.name.updateContext=function(t){var e=!1;this.options.ecmaVersion>=6&&("of"==this.value&&!this.exprAllowed||"yield"==this.value&&this.inGeneratorContext())&&(e=!0),this.exprAllowed=e};var lt=function(t){this.type=t.type,this.value=t.value,this.start=t.start,this.end=t.end,t.options.locations&&(this.loc=new W(t,t.startLoc,t.endLoc)),t.options.ranges&&(this.range=[t.start,t.end])},ut=$.prototype,dt="object"==typeof Packages&&"[object JavaPackage]"==Object.prototype.toString.call(Packages);ut.next=function(){this.options.onToken&&this.options.onToken(new lt(this)),this.lastTokEnd=this.end,this.lastTokStart=this.start,this.lastTokEndLoc=this.endLoc,this.lastTokStartLoc=this.startLoc,this.nextToken()},ut.getToken=function(){return this.next(),new lt(this)},"undefined"!=typeof Symbol&&(ut[Symbol.iterator]=function(){var t=this;return{next:function(){var e=t.getToken();return{done:e.type===V.eof,value:e}}}}),ut.curContext=function(){return this.context[this.context.length-1]},ut.nextToken=function(){var t=this.curContext();return t&&t.preserveSpace||this.skipSpace(),this.start=this.pos,this.options.locations&&(this.startLoc=this.curPosition()),this.pos>=this.input.length?this.finishToken(V.eof):t.override?t.override(this):void this.readToken(this.fullCharCodeAtPos())},ut.readToken=function(t){return s(t,this.options.ecmaVersion>=6)||92===t?this.readWord():this.getTokenFromCode(t)},ut.fullCharCodeAtPos=function(){var t=this.input.charCodeAt(this.pos);return t<=55295||t>=57344?t:(t<<10)+this.input.charCodeAt(this.pos+1)-56613888},ut.skipBlockComment=function(){var t=this,e=this.options.onComment&&this.curPosition(),s=this.pos,i=this.input.indexOf("*/",this.pos+=2);if(-1===i&&this.raise(this.pos-2,"Unterminated comment"),this.pos=i+2,this.options.locations){D.lastIndex=s;for(var r;(r=D.exec(this.input))&&r.index<this.pos;)++t.curLine,t.lineStart=r.index+r[0].length}this.options.onComment&&this.options.onComment(!0,this.input.slice(s+2,i),s,this.pos,e,this.curPosition())},ut.skipLineComment=function(t){for(var e=this,s=this.pos,i=this.options.onComment&&this.curPosition(),r=this.input.charCodeAt(this.pos+=t);this.pos<this.input.length&&!a(r);)r=e.input.charCodeAt(++e.pos);this.options.onComment&&this.options.onComment(!1,this.input.slice(s+t,this.pos),s,this.pos,i,this.curPosition())},ut.skipSpace=function(){var t=this;t:for(;this.pos<this.input.length;){var e=t.input.charCodeAt(t.pos);switch(e){case 32:case 160:++t.pos;break;case 13:10===t.input.charCodeAt(t.pos+1)&&++t.pos;case 10:case 8232:case 8233:++t.pos,t.options.locations&&(++t.curLine,t.lineStart=t.pos);break;case 47:switch(t.input.charCodeAt(t.pos+1)){case 42:t.skipBlockComment();break;case 47:t.skipLineComment(2);break;default:break t}break;default:if(!(e>8&&e<14||e>=5760&&B.test(String.fromCharCode(e))))break t;++t.pos}}},ut.finishToken=function(t,e){this.end=this.pos,this.options.locations&&(this.endLoc=this.curPosition());var s=this.type;this.type=t,this.value=e,this.updateContext(s)},ut.readToken_dot=function(){var t=this.input.charCodeAt(this.pos+1);if(t>=48&&t<=57)return this.readNumber(!0);var e=this.input.charCodeAt(this.pos+2);return this.options.ecmaVersion>=6&&46===t&&46===e?(this.pos+=3,this.finishToken(V.ellipsis)):(++this.pos,this.finishToken(V.dot))},ut.readToken_slash=function(){var t=this.input.charCodeAt(this.pos+1);return this.exprAllowed?(++this.pos,this.readRegexp()):61===t?this.finishOp(V.assign,2):this.finishOp(V.slash,1)},ut.readToken_mult_modulo_exp=function(t){var e=this.input.charCodeAt(this.pos+1),s=1,i=42===t?V.star:V.modulo;return this.options.ecmaVersion>=7&&42==t&&42===e&&(++s,i=V.starstar,e=this.input.charCodeAt(this.pos+2)),61===e?this.finishOp(V.assign,s+1):this.finishOp(i,s)},ut.readToken_pipe_amp=function(t){var e=this.input.charCodeAt(this.pos+1);return e===t?this.finishOp(124===t?V.logicalOR:V.logicalAND,2):61===e?this.finishOp(V.assign,2):this.finishOp(124===t?V.bitwiseOR:V.bitwiseAND,1)},ut.readToken_caret=function(){return 61===this.input.charCodeAt(this.pos+1)?this.finishOp(V.assign,2):this.finishOp(V.bitwiseXOR,1)},ut.readToken_plus_min=function(t){var e=this.input.charCodeAt(this.pos+1);return e===t?45!=e||this.inModule||62!=this.input.charCodeAt(this.pos+2)||0!==this.lastTokEnd&&!F.test(this.input.slice(this.lastTokEnd,this.pos))?this.finishOp(V.incDec,2):(this.skipLineComment(3),this.skipSpace(),this.nextToken()):61===e?this.finishOp(V.assign,2):this.finishOp(V.plusMin,1)},ut.readToken_lt_gt=function(t){var e=this.input.charCodeAt(this.pos+1),s=1;return e===t?(s=62===t&&62===this.input.charCodeAt(this.pos+2)?3:2,61===this.input.charCodeAt(this.pos+s)?this.finishOp(V.assign,s+1):this.finishOp(V.bitShift,s)):33!=e||60!=t||this.inModule||45!=this.input.charCodeAt(this.pos+2)||45!=this.input.charCodeAt(this.pos+3)?(61===e&&(s=2),this.finishOp(V.relational,s)):(this.skipLineComment(4),this.skipSpace(),this.nextToken())},ut.readToken_eq_excl=function(t){var e=this.input.charCodeAt(this.pos+1);return 61===e?this.finishOp(V.equality,61===this.input.charCodeAt(this.pos+2)?3:2):61===t&&62===e&&this.options.ecmaVersion>=6?(this.pos+=2,this.finishToken(V.arrow)):this.finishOp(61===t?V.eq:V.prefix,1)},ut.getTokenFromCode=function(t){switch(t){case 46:return this.readToken_dot();case 40:return++this.pos,this.finishToken(V.parenL);case 41:return++this.pos,this.finishToken(V.parenR);case 59:return++this.pos,this.finishToken(V.semi);case 44:return++this.pos,this.finishToken(V.comma);case 91:return++this.pos,this.finishToken(V.bracketL);case 93:return++this.pos,this.finishToken(V.bracketR);case 123:return++this.pos,this.finishToken(V.braceL);case 125:return++this.pos,this.finishToken(V.braceR);case 58:return++this.pos,this.finishToken(V.colon);case 63:return++this.pos,this.finishToken(V.question);case 96:if(this.options.ecmaVersion<6)break;return++this.pos,this.finishToken(V.backQuote);case 48:var e=this.input.charCodeAt(this.pos+1);if(120===e||88===e)return this.readRadixNumber(16);if(this.options.ecmaVersion>=6){if(111===e||79===e)return this.readRadixNumber(8);if(98===e||66===e)return this.readRadixNumber(2)}case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return this.readNumber(!1);case 34:case 39:return this.readString(t);case 47:return this.readToken_slash();case 37:case 42:return this.readToken_mult_modulo_exp(t);case 124:case 38:return this.readToken_pipe_amp(t);case 94:return this.readToken_caret();case 43:case 45:return this.readToken_plus_min(t);case 60:case 62:return this.readToken_lt_gt(t);case 61:case 33:return this.readToken_eq_excl(t);case 126:return this.finishOp(V.prefix,1)}this.raise(this.pos,"Unexpected character '"+m(t)+"'")},ut.finishOp=function(t,e){var s=this.input.slice(this.pos,this.pos+e);return this.pos+=e,this.finishToken(t,s)};var ft=!!f("￿","u");ut.readRegexp=function(){for(var t,e,s=this,i=this.pos;;){s.pos>=s.input.length&&s.raise(i,"Unterminated regular expression");var r=s.input.charAt(s.pos);if(F.test(r)&&s.raise(i,"Unterminated regular expression"),t)t=!1;else{if("["===r)e=!0;else if("]"===r&&e)e=!1;else if("/"===r&&!e)break;t="\\"===r}++s.pos}var n=this.input.slice(i,this.pos);++this.pos;var a=this.readWord1(),o=n,h="";if(a){var p=/^[gim]*$/;this.options.ecmaVersion>=6&&(p=/^[gimuy]*$/),this.options.ecmaVersion>=9&&(p=/^[gimsuy]*$/),p.test(a)||this.raise(i,"Invalid regular expression flag"),a.indexOf("u")>=0&&(ft?h="u":(o=o.replace(/\\u\{([0-9a-fA-F]+)\}/g,function(t,e,r){return e=Number("0x"+e),e>1114111&&s.raise(i+r+3,"Code point out of bounds"),"x"}),o=o.replace(/\\u([a-fA-F0-9]{4})|[\uD800-\uDBFF][\uDC00-\uDFFF]/g,"x"),h=h.replace("u","")))}var c=null;return dt||(f(o,h,i,this),c=f(n,a)),this.finishToken(V.regexp,{pattern:n,flags:a,value:c})},ut.readInt=function(t,e){for(var s=this,i=this.pos,r=0,n=0,a=null==e?1/0:e;n<a;++n){var o=s.input.charCodeAt(s.pos),h=void 0;if((h=o>=97?o-97+10:o>=65?o-65+10:o>=48&&o<=57?o-48:1/0)>=t)break;++s.pos,r=r*t+h}return this.pos===i||null!=e&&this.pos-i!==e?null:r},ut.readRadixNumber=function(t){this.pos+=2;var e=this.readInt(t);return null==e&&this.raise(this.start+2,"Expected number in radix "+t),s(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number"),this.finishToken(V.num,e)},ut.readNumber=function(t){var e=this.pos;t||null!==this.readInt(10)||this.raise(e,"Invalid number");var i=this.pos-e>=2&&48===this.input.charCodeAt(e);i&&this.strict&&this.raise(e,"Invalid number"),i&&/[89]/.test(this.input.slice(e,this.pos))&&(i=!1);var r=this.input.charCodeAt(this.pos)
-;46!==r||i||(++this.pos,this.readInt(10),r=this.input.charCodeAt(this.pos)),69!==r&&101!==r||i||(r=this.input.charCodeAt(++this.pos),43!==r&&45!==r||++this.pos,null===this.readInt(10)&&this.raise(e,"Invalid number")),s(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number");var n=this.input.slice(e,this.pos),a=i?parseInt(n,8):parseFloat(n);return this.finishToken(V.num,a)},ut.readCodePoint=function(){var t,e=this.input.charCodeAt(this.pos);if(123===e){this.options.ecmaVersion<6&&this.unexpected();var s=++this.pos;t=this.readHexChar(this.input.indexOf("}",this.pos)-this.pos),++this.pos,t>1114111&&this.invalidStringToken(s,"Code point out of bounds")}else t=this.readHexChar(4);return t},ut.readString=function(t){for(var e=this,s="",i=++this.pos;;){e.pos>=e.input.length&&e.raise(e.start,"Unterminated string constant");var r=e.input.charCodeAt(e.pos);if(r===t)break;92===r?(s+=e.input.slice(i,e.pos),s+=e.readEscapedChar(!1),i=e.pos):(a(r)&&e.raise(e.start,"Unterminated string constant"),++e.pos)}return s+=this.input.slice(i,this.pos++),this.finishToken(V.string,s)};var mt={};ut.tryReadTemplateToken=function(){this.inTemplateElement=!0;try{this.readTmplToken()}catch(t){if(t!==mt)throw t;this.readInvalidTemplateToken()}this.inTemplateElement=!1},ut.invalidStringToken=function(t,e){if(this.inTemplateElement&&this.options.ecmaVersion>=9)throw mt;this.raise(t,e)},ut.readTmplToken=function(){for(var t=this,e="",s=this.pos;;){t.pos>=t.input.length&&t.raise(t.start,"Unterminated template");var i=t.input.charCodeAt(t.pos);if(96===i||36===i&&123===t.input.charCodeAt(t.pos+1))return t.pos!==t.start||t.type!==V.template&&t.type!==V.invalidTemplate?(e+=t.input.slice(s,t.pos),t.finishToken(V.template,e)):36===i?(t.pos+=2,t.finishToken(V.dollarBraceL)):(++t.pos,t.finishToken(V.backQuote));if(92===i)e+=t.input.slice(s,t.pos),e+=t.readEscapedChar(!0),s=t.pos;else if(a(i)){switch(e+=t.input.slice(s,t.pos),++t.pos,i){case 13:10===t.input.charCodeAt(t.pos)&&++t.pos;case 10:e+="\n";break;default:e+=String.fromCharCode(i)}t.options.locations&&(++t.curLine,t.lineStart=t.pos),s=t.pos}else++t.pos}},ut.readInvalidTemplateToken=function(){for(var t=this;this.pos<this.input.length;this.pos++)switch(t.input[t.pos]){case"\\":++t.pos;break;case"$":if("{"!==t.input[t.pos+1])break;case"`":return t.finishToken(V.invalidTemplate,t.input.slice(t.start,t.pos))}this.raise(this.start,"Unterminated template")},ut.readEscapedChar=function(t){var e=this.input.charCodeAt(++this.pos);switch(++this.pos,e){case 110:return"\n";case 114:return"\r";case 120:return String.fromCharCode(this.readHexChar(2));case 117:return m(this.readCodePoint());case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===this.input.charCodeAt(this.pos)&&++this.pos;case 10:return this.options.locations&&(this.lineStart=this.pos,++this.curLine),"";default:if(e>=48&&e<=55){var s=this.input.substr(this.pos-1,3).match(/^[0-7]+/)[0],i=parseInt(s,8);return i>255&&(s=s.slice(0,-1),i=parseInt(s,8)),"0"!==s&&(this.strict||t)&&this.invalidStringToken(this.pos-2,"Octal literal in strict mode"),this.pos+=s.length-1,String.fromCharCode(i)}return String.fromCharCode(e)}},ut.readHexChar=function(t){var e=this.pos,s=this.readInt(16,t);return null===s&&this.invalidStringToken(e,"Bad character escape sequence"),s},ut.readWord1=function(){var t=this;this.containsEsc=!1;for(var e="",r=!0,n=this.pos,a=this.options.ecmaVersion>=6;this.pos<this.input.length;){var o=t.fullCharCodeAtPos();if(i(o,a))t.pos+=o<=65535?1:2;else{if(92!==o)break;t.containsEsc=!0,e+=t.input.slice(n,t.pos);var h=t.pos;117!=t.input.charCodeAt(++t.pos)&&t.invalidStringToken(t.pos,"Expecting Unicode escape sequence \\uXXXX"),++t.pos;var p=t.readCodePoint();(r?s:i)(p,a)||t.invalidStringToken(h,"Invalid Unicode escape"),e+=m(p),n=t.pos}r=!1}return e+this.input.slice(n,this.pos)},ut.readWord=function(){var t=this.readWord1(),e=V.name;return this.keywords.test(t)&&(this.containsEsc&&this.raiseRecoverable(this.start,"Escape sequence in keyword "+t),e=R[t]),this.finishToken(e,t)};t.version="5.3.0",t.parse=x,t.parseExpressionAt=y,t.tokenizer=v,t.addLooseExports=b,t.Parser=$,t.plugins=Y,t.defaultOptions=G,t.Position=j,t.SourceLocation=W,t.getLineInfo=h,t.Node=at,t.TokenType=T,t.tokTypes=V,t.keywordTypes=R,t.TokContext=ht,t.tokContexts=pt,t.isIdentifierChar=i,t.isIdentifierStart=s,t.Token=lt,t.isNewLine=a,t.lineBreak=F,t.lineBreakG=D,t.nonASCIIwhitespace=B,Object.defineProperty(t,"__esModule",{value:!0})});
-},{}],77:[function(require,module,exports){
+
+},{"./backend/cpu/function-builder":51,"./backend/cpu/function-node":52,"./backend/cpu/kernel":54,"./backend/cpu/runner":55,"./backend/web-gl/function-builder":61,"./backend/web-gl/function-node":62,"./backend/web-gl/kernel":64,"./backend/web-gl/runner":65,"./core/alias":69,"./core/gpu":71,"./core/input":72,"./core/texture":73,"./core/utils":75}],77:[function(require,module,exports){
 exports.read=function(a,o,t,r,h){var M,p,w=8*h-r-1,f=(1<<w)-1,e=f>>1,i=-7,N=t?h-1:0,n=t?-1:1,s=a[o+N];for(N+=n,M=s&(1<<-i)-1,s>>=-i,i+=w;i>0;M=256*M+a[o+N],N+=n,i-=8);for(p=M&(1<<-i)-1,M>>=-i,i+=r;i>0;p=256*p+a[o+N],N+=n,i-=8);if(0===M)M=1-e;else{if(M===f)return p?NaN:1/0*(s?-1:1);p+=Math.pow(2,r),M-=e}return(s?-1:1)*p*Math.pow(2,M-r)},exports.write=function(a,o,t,r,h,M){var p,w,f,e=8*M-h-1,i=(1<<e)-1,N=i>>1,n=23===h?Math.pow(2,-24)-Math.pow(2,-77):0,s=r?0:M-1,u=r?1:-1,l=o<0||0===o&&1/o<0?1:0;for(o=Math.abs(o),isNaN(o)||o===1/0?(w=isNaN(o)?1:0,p=i):(p=Math.floor(Math.log(o)/Math.LN2),o*(f=Math.pow(2,-p))<1&&(p--,f*=2),o+=p+N>=1?n/f:n*Math.pow(2,1-N),o*f>=2&&(p++,f/=2),p+N>=i?(w=0,p=i):p+N>=1?(w=(o*f-1)*Math.pow(2,h),p+=N):(w=o*Math.pow(2,N-1)*Math.pow(2,h),p=0));h>=8;a[t+s]=255&w,s+=u,w/=256,h-=8);for(p=p<<h|w,e+=h;e>0;a[t+s]=255&p,s+=u,p/=256,e-=8);a[t+s-u]|=128*l};
 
 },{}],78:[function(require,module,exports){
 "function"==typeof Object.create?module.exports=function(t,e){t.super_=e,t.prototype=Object.create(e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}})}:module.exports=function(t,e){t.super_=e;var o=function(){};o.prototype=e.prototype,t.prototype=new o,t.prototype.constructor=t};
 },{}],79:[function(require,module,exports){
 function isBuffer(f){return!!f.constructor&&"function"==typeof f.constructor.isBuffer&&f.constructor.isBuffer(f)}function isSlowBuffer(f){return"function"==typeof f.readFloatLE&&"function"==typeof f.slice&&isBuffer(f.slice(0,0))}module.exports=function(f){return null!=f&&(isBuffer(f)||isSlowBuffer(f)||!!f._isBuffer)};
+
 },{}],80:[function(require,module,exports){
 var toString={}.toString;module.exports=Array.isArray||function(r){return"[object Array]"==toString.call(r)};
 
@@ -353,56 +362,54 @@ module.exports=require("./lib/_stream_duplex.js");
 },{"./lib/_stream_duplex.js":84}],84:[function(require,module,exports){
 "use strict";function Duplex(e){if(!(this instanceof Duplex))return new Duplex(e);Readable.call(this,e),Writable.call(this,e),e&&!1===e.readable&&(this.readable=!1),e&&!1===e.writable&&(this.writable=!1),this.allowHalfOpen=!0,e&&!1===e.allowHalfOpen&&(this.allowHalfOpen=!1),this.once("end",onend)}function onend(){this.allowHalfOpen||this._writableState.ended||processNextTick(onEndNT,this)}function onEndNT(e){e.end()}function forEach(e,t){for(var r=0,i=e.length;r<i;r++)t(e[r],r)}var processNextTick=require("process-nextick-args"),objectKeys=Object.keys||function(e){var t=[];for(var r in e)t.push(r);return t};module.exports=Duplex;var util=require("core-util-is");util.inherits=require("inherits");var Readable=require("./_stream_readable"),Writable=require("./_stream_writable");util.inherits(Duplex,Readable);for(var keys=objectKeys(Writable.prototype),v=0;v<keys.length;v++){var method=keys[v];Duplex.prototype[method]||(Duplex.prototype[method]=Writable.prototype[method])}Object.defineProperty(Duplex.prototype,"destroyed",{get:function(){return void 0!==this._readableState&&void 0!==this._writableState&&(this._readableState.destroyed&&this._writableState.destroyed)},set:function(e){void 0!==this._readableState&&void 0!==this._writableState&&(this._readableState.destroyed=e,this._writableState.destroyed=e)}}),Duplex.prototype._destroy=function(e,t){this.push(null),this.end(),processNextTick(t,e)};
 
-},{"./_stream_readable":86,"./_stream_writable":88,"core-util-is":48,"inherits":78,"process-nextick-args":81}],85:[function(require,module,exports){
+},{"./_stream_readable":86,"./_stream_writable":88,"core-util-is":49,"inherits":78,"process-nextick-args":81}],85:[function(require,module,exports){
 "use strict";function PassThrough(r){if(!(this instanceof PassThrough))return new PassThrough(r);Transform.call(this,r)}module.exports=PassThrough;var Transform=require("./_stream_transform"),util=require("core-util-is");util.inherits=require("inherits"),util.inherits(PassThrough,Transform),PassThrough.prototype._transform=function(r,s,i){i(null,r)};
 
-},{"./_stream_transform":87,"core-util-is":48,"inherits":78}],86:[function(require,module,exports){
+},{"./_stream_transform":87,"core-util-is":49,"inherits":78}],86:[function(require,module,exports){
 (function (process,global){
 "use strict";function _uint8ArrayToBuffer(e){return Buffer.from(e)}function _isUint8Array(e){return Buffer.isBuffer(e)||e instanceof OurUint8Array}function prependListener(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?isArray(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}function ReadableState(e,t){Duplex=Duplex||require("./_stream_duplex"),e=e||{},this.objectMode=!!e.objectMode,t instanceof Duplex&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var r=e.highWaterMark,n=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:n,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new BufferList,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(StringDecoder||(StringDecoder=require("string_decoder/").StringDecoder),this.decoder=new StringDecoder(e.encoding),this.encoding=e.encoding)}function Readable(e){if(Duplex=Duplex||require("./_stream_duplex"),!(this instanceof Readable))return new Readable(e);this._readableState=new ReadableState(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),Stream.call(this)}function readableAddChunk(e,t,r,n,a){var i=e._readableState;if(null===t)i.reading=!1,onEofChunk(e,i);else{var d;a||(d=chunkInvalid(i,t)),d?e.emit("error",d):i.objectMode||t&&t.length>0?("string"==typeof t||i.objectMode||Object.getPrototypeOf(t)===Buffer.prototype||(t=_uint8ArrayToBuffer(t)),n?i.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):addChunk(e,i,t,!0):i.ended?e.emit("error",new Error("stream.push() after EOF")):(i.reading=!1,i.decoder&&!r?(t=i.decoder.write(t),i.objectMode||0!==t.length?addChunk(e,i,t,!1):maybeReadMore(e,i)):addChunk(e,i,t,!1))):n||(i.reading=!1)}return needMoreData(i)}function addChunk(e,t,r,n){t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,n?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&emitReadable(e)),maybeReadMore(e,t)}function chunkInvalid(e,t){var r;return _isUint8Array(t)||"string"==typeof t||void 0===t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk")),r}function needMoreData(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function computeNewHighWaterMark(e){return e>=MAX_HWM?e=MAX_HWM:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}function howMuchToRead(e,t){return e<=0||0===t.length&&t.ended?0:t.objectMode?1:e!==e?t.flowing&&t.length?t.buffer.head.data.length:t.length:(e>t.highWaterMark&&(t.highWaterMark=computeNewHighWaterMark(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function onEofChunk(e,t){if(!t.ended){if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,emitReadable(e)}}function emitReadable(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(debug("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?processNextTick(emitReadable_,e):emitReadable_(e))}function emitReadable_(e){debug("emit readable"),e.emit("readable"),flow(e)}function maybeReadMore(e,t){t.readingMore||(t.readingMore=!0,processNextTick(maybeReadMore_,e,t))}function maybeReadMore_(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(debug("maybeReadMore read 0"),e.read(0),r!==t.length);)r=t.length;t.readingMore=!1}function pipeOnDrain(e){return function(){var t=e._readableState;debug("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&EElistenerCount(e,"data")&&(t.flowing=!0,flow(e))}}function nReadingNextTick(e){debug("readable nexttick read 0"),e.read(0)}function resume(e,t){t.resumeScheduled||(t.resumeScheduled=!0,processNextTick(resume_,e,t))}function resume_(e,t){t.reading||(debug("resume read 0"),e.read(0)),t.resumeScheduled=!1,t.awaitDrain=0,e.emit("resume"),flow(e),t.flowing&&!t.reading&&e.read(0)}function flow(e){var t=e._readableState;for(debug("flow",t.flowing);t.flowing&&null!==e.read(););}function fromList(e,t){if(0===t.length)return null;var r;return t.objectMode?r=t.buffer.shift():!e||e>=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=fromListPartial(e,t.buffer,t.decoder),r}function fromListPartial(e,t,r){var n;return e<t.head.data.length?(n=t.head.data.slice(0,e),t.head.data=t.head.data.slice(e)):n=e===t.head.data.length?t.shift():r?copyFromBufferString(e,t):copyFromBuffer(e,t),n}function copyFromBufferString(e,t){var r=t.head,n=1,a=r.data;for(e-=a.length;r=r.next;){var i=r.data,d=e>i.length?i.length:e;if(d===i.length?a+=i:a+=i.slice(0,e),0===(e-=d)){d===i.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(d));break}++n}return t.length-=n,a}function copyFromBuffer(e,t){var r=Buffer.allocUnsafe(e),n=t.head,a=1;for(n.data.copy(r),e-=n.data.length;n=n.next;){var i=n.data,d=e>i.length?i.length:e;if(i.copy(r,r.length-e,0,d),0===(e-=d)){d===i.length?(++a,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=i.slice(d));break}++a}return t.length-=a,r}function endReadable(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,processNextTick(endReadableNT,t,e))}function endReadableNT(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function forEach(e,t){for(var r=0,n=e.length;r<n;r++)t(e[r],r)}function indexOf(e,t){for(var r=0,n=e.length;r<n;r++)if(e[r]===t)return r;return-1}var processNextTick=require("process-nextick-args");module.exports=Readable;var isArray=require("isarray"),Duplex;Readable.ReadableState=ReadableState;var EE=require("events").EventEmitter,EElistenerCount=function(e,t){return e.listeners(t).length},Stream=require("./internal/streams/stream"),Buffer=require("safe-buffer").Buffer,OurUint8Array=global.Uint8Array||function(){},util=require("core-util-is");util.inherits=require("inherits");var debugUtil=require("util"),debug=void 0;debug=debugUtil&&debugUtil.debuglog?debugUtil.debuglog("stream"):function(){};var BufferList=require("./internal/streams/BufferList"),destroyImpl=require("./internal/streams/destroy"),StringDecoder;util.inherits(Readable,Stream);var kProxyEvents=["error","close","destroy","pause","resume"];Object.defineProperty(Readable.prototype,"destroyed",{get:function(){return void 0!==this._readableState&&this._readableState.destroyed},set:function(e){this._readableState&&(this._readableState.destroyed=e)}}),Readable.prototype.destroy=destroyImpl.destroy,Readable.prototype._undestroy=destroyImpl.undestroy,Readable.prototype._destroy=function(e,t){this.push(null),t(e)},Readable.prototype.push=function(e,t){var r,n=this._readableState;return n.objectMode?r=!0:"string"==typeof e&&(t=t||n.defaultEncoding,t!==n.encoding&&(e=Buffer.from(e,t),t=""),r=!0),readableAddChunk(this,e,t,!1,r)},Readable.prototype.unshift=function(e){return readableAddChunk(this,e,null,!0,!1)},Readable.prototype.isPaused=function(){return!1===this._readableState.flowing},Readable.prototype.setEncoding=function(e){return StringDecoder||(StringDecoder=require("string_decoder/").StringDecoder),this._readableState.decoder=new StringDecoder(e),this._readableState.encoding=e,this};var MAX_HWM=8388608;Readable.prototype.read=function(e){debug("read",e),e=parseInt(e,10);var t=this._readableState,r=e;if(0!==e&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return debug("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?endReadable(this):emitReadable(this),null;if(0===(e=howMuchToRead(e,t))&&t.ended)return 0===t.length&&endReadable(this),null;var n=t.needReadable;debug("need readable",n),(0===t.length||t.length-e<t.highWaterMark)&&(n=!0,debug("length less than watermark",n)),t.ended||t.reading?(n=!1,debug("reading or ended",n)):n&&(debug("do read"),t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1,t.reading||(e=howMuchToRead(r,t)));var a;return a=e>0?fromList(e,t):null,null===a?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&endReadable(this)),null!==a&&this.emit("data",a),a},Readable.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},Readable.prototype.pipe=function(e,t){function r(e,t){debug("onunpipe"),e===l&&t&&!1===t.hasUnpiped&&(t.hasUnpiped=!0,a())}function n(){debug("onend"),e.end()}function a(){debug("cleanup"),e.removeListener("close",o),e.removeListener("finish",u),e.removeListener("drain",c),e.removeListener("error",d),e.removeListener("unpipe",r),l.removeListener("end",n),l.removeListener("end",s),l.removeListener("data",i),b=!0,!h.awaitDrain||e._writableState&&!e._writableState.needDrain||c()}function i(t){debug("ondata"),g=!1,!1!==e.write(t)||g||((1===h.pipesCount&&h.pipes===e||h.pipesCount>1&&-1!==indexOf(h.pipes,e))&&!b&&(debug("false write response, pause",l._readableState.awaitDrain),l._readableState.awaitDrain++,g=!0),l.pause())}function d(t){debug("onerror",t),s(),e.removeListener("error",d),0===EElistenerCount(e,"error")&&e.emit("error",t)}function o(){e.removeListener("finish",u),s()}function u(){debug("onfinish"),e.removeListener("close",o),s()}function s(){debug("unpipe"),l.unpipe(e)}var l=this,h=this._readableState;switch(h.pipesCount){case 0:h.pipes=e;break;case 1:h.pipes=[h.pipes,e];break;default:h.pipes.push(e)}h.pipesCount+=1,debug("pipe count=%d opts=%j",h.pipesCount,t);var f=(!t||!1!==t.end)&&e!==process.stdout&&e!==process.stderr,p=f?n:s;h.endEmitted?processNextTick(p):l.once("end",p),e.on("unpipe",r);var c=pipeOnDrain(l);e.on("drain",c);var b=!1,g=!1;return l.on("data",i),prependListener(e,"error",d),e.once("close",o),e.once("finish",u),e.emit("pipe",l),h.flowing||(debug("pipe resume"),l.resume()),e},Readable.prototype.unpipe=function(e){var t=this._readableState,r={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,r),this);if(!e){var n=t.pipes,a=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i<a;i++)n[i].emit("unpipe",this,r);return this}var d=indexOf(t.pipes,e);return-1===d?this:(t.pipes.splice(d,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this,r),this)},Readable.prototype.on=function(e,t){var r=Stream.prototype.on.call(this,e,t);if("data"===e)!1!==this._readableState.flowing&&this.resume();else if("readable"===e){var n=this._readableState;n.endEmitted||n.readableListening||(n.readableListening=n.needReadable=!0,n.emittedReadable=!1,n.reading?n.length&&emitReadable(this):processNextTick(nReadingNextTick,this))}return r},Readable.prototype.addListener=Readable.prototype.on,Readable.prototype.resume=function(){var e=this._readableState;return e.flowing||(debug("resume"),e.flowing=!0,resume(this,e)),this},Readable.prototype.pause=function(){return debug("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(debug("pause"),this._readableState.flowing=!1,this.emit("pause")),this},Readable.prototype.wrap=function(e){var t=this._readableState,r=!1,n=this;e.on("end",function(){if(debug("wrapped end"),t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&n.push(e)}n.push(null)}),e.on("data",function(a){if(debug("wrapped data"),t.decoder&&(a=t.decoder.write(a)),(!t.objectMode||null!==a&&void 0!==a)&&(t.objectMode||a&&a.length)){n.push(a)||(r=!0,e.pause())}});for(var a in e)void 0===this[a]&&"function"==typeof e[a]&&(this[a]=function(t){return function(){return e[t].apply(e,arguments)}}(a));for(var i=0;i<kProxyEvents.length;i++)e.on(kProxyEvents[i],n.emit.bind(n,kProxyEvents[i]));return n._read=function(t){debug("wrapped _read",t),r&&(r=!1,e.resume())},n},Readable._fromList=fromList;
 
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":84,"./internal/streams/BufferList":89,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":48,"events":49,"inherits":78,"isarray":80,"process-nextick-args":81,"safe-buffer":97,"string_decoder/":92,"util":46}],87:[function(require,module,exports){
+},{"./_stream_duplex":84,"./internal/streams/BufferList":89,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":49,"events":50,"inherits":78,"isarray":80,"process-nextick-args":81,"safe-buffer":96,"string_decoder/":98,"util":47}],87:[function(require,module,exports){
 "use strict";function TransformState(r){this.afterTransform=function(t,n){return afterTransform(r,t,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null,this.writeencoding=null}function afterTransform(r,t,n){var e=r._transformState;e.transforming=!1;var i=e.writecb;if(!i)return r.emit("error",new Error("write callback called multiple times"));e.writechunk=null,e.writecb=null,null!==n&&void 0!==n&&r.push(n),i(t);var a=r._readableState;a.reading=!1,(a.needReadable||a.length<a.highWaterMark)&&r._read(a.highWaterMark)}function Transform(r){if(!(this instanceof Transform))return new Transform(r);Duplex.call(this,r),this._transformState=new TransformState(this);var t=this;this._readableState.needReadable=!0,this._readableState.sync=!1,r&&("function"==typeof r.transform&&(this._transform=r.transform),"function"==typeof r.flush&&(this._flush=r.flush)),this.once("prefinish",function(){"function"==typeof this._flush?this._flush(function(r,n){done(t,r,n)}):done(t)})}function done(r,t,n){if(t)return r.emit("error",t);null!==n&&void 0!==n&&r.push(n);var e=r._writableState,i=r._transformState;if(e.length)throw new Error("Calling transform done when ws.length != 0");if(i.transforming)throw new Error("Calling transform done when still transforming");return r.push(null)}module.exports=Transform;var Duplex=require("./_stream_duplex"),util=require("core-util-is");util.inherits=require("inherits"),util.inherits(Transform,Duplex),Transform.prototype.push=function(r,t){return this._transformState.needTransform=!1,Duplex.prototype.push.call(this,r,t)},Transform.prototype._transform=function(r,t,n){throw new Error("_transform() is not implemented")},Transform.prototype._write=function(r,t,n){var e=this._transformState;if(e.writecb=n,e.writechunk=r,e.writeencoding=t,!e.transforming){var i=this._readableState;(e.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},Transform.prototype._read=function(r){var t=this._transformState;null!==t.writechunk&&t.writecb&&!t.transforming?(t.transforming=!0,this._transform(t.writechunk,t.writeencoding,t.afterTransform)):t.needTransform=!0},Transform.prototype._destroy=function(r,t){var n=this;Duplex.prototype._destroy.call(this,r,function(r){t(r),n.emit("close")})};
 
-},{"./_stream_duplex":84,"core-util-is":48,"inherits":78}],88:[function(require,module,exports){
+},{"./_stream_duplex":84,"core-util-is":49,"inherits":78}],88:[function(require,module,exports){
 (function (process,global){
 "use strict";function WriteReq(e,t,r){this.chunk=e,this.encoding=t,this.callback=r,this.next=null}function CorkedRequest(e){var t=this;this.next=null,this.entry=null,this.finish=function(){onCorkedFinish(t,e)}}function _uint8ArrayToBuffer(e){return Buffer.from(e)}function _isUint8Array(e){return Buffer.isBuffer(e)||e instanceof OurUint8Array}function nop(){}function WritableState(e,t){Duplex=Duplex||require("./_stream_duplex"),e=e||{},this.objectMode=!!e.objectMode,t instanceof Duplex&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var r=e.highWaterMark,i=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:i,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var n=!1===e.decodeStrings;this.decodeStrings=!n,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){onwrite(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new CorkedRequest(this)}function Writable(e){if(Duplex=Duplex||require("./_stream_duplex"),!(realHasInstance.call(Writable,this)||this instanceof Duplex))return new Writable(e);this._writableState=new WritableState(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),Stream.call(this)}function writeAfterEnd(e,t){var r=new Error("write after end");e.emit("error",r),processNextTick(t,r)}function validChunk(e,t,r,i){var n=!0,o=!1;return null===r?o=new TypeError("May not write null values to stream"):"string"==typeof r||void 0===r||t.objectMode||(o=new TypeError("Invalid non-string/buffer chunk")),o&&(e.emit("error",o),processNextTick(i,o),n=!1),n}function decodeChunk(e,t,r){return e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=Buffer.from(t,r)),t}function writeOrBuffer(e,t,r,i,n,o){if(!r){var s=decodeChunk(t,i,n);i!==s&&(r=!0,n="buffer",i=s)}var a=t.objectMode?1:i.length;t.length+=a;var f=t.length<t.highWaterMark;if(f||(t.needDrain=!0),t.writing||t.corked){var u=t.lastBufferedRequest;t.lastBufferedRequest={chunk:i,encoding:n,isBuf:r,callback:o,next:null},u?u.next=t.lastBufferedRequest:t.bufferedRequest=t.lastBufferedRequest,t.bufferedRequestCount+=1}else doWrite(e,t,!1,a,i,n,o);return f}function doWrite(e,t,r,i,n,o,s){t.writelen=i,t.writecb=s,t.writing=!0,t.sync=!0,r?e._writev(n,t.onwrite):e._write(n,o,t.onwrite),t.sync=!1}function onwriteError(e,t,r,i,n){--t.pendingcb,r?(processNextTick(n,i),processNextTick(finishMaybe,e,t),e._writableState.errorEmitted=!0,e.emit("error",i)):(n(i),e._writableState.errorEmitted=!0,e.emit("error",i),finishMaybe(e,t))}function onwriteStateUpdate(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function onwrite(e,t){var r=e._writableState,i=r.sync,n=r.writecb;if(onwriteStateUpdate(r),t)onwriteError(e,r,i,t,n);else{var o=needFinish(r);o||r.corked||r.bufferProcessing||!r.bufferedRequest||clearBuffer(e,r),i?asyncWrite(afterWrite,e,r,o,n):afterWrite(e,r,o,n)}}function afterWrite(e,t,r,i){r||onwriteDrain(e,t),t.pendingcb--,i(),finishMaybe(e,t)}function onwriteDrain(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function clearBuffer(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var i=t.bufferedRequestCount,n=new Array(i),o=t.corkedRequestsFree;o.entry=r;for(var s=0,a=!0;r;)n[s]=r,r.isBuf||(a=!1),r=r.next,s+=1;n.allBuffers=a,doWrite(e,t,!0,t.length,n,"",o.finish),t.pendingcb++,t.lastBufferedRequest=null,o.next?(t.corkedRequestsFree=o.next,o.next=null):t.corkedRequestsFree=new CorkedRequest(t)}else{for(;r;){var f=r.chunk,u=r.encoding,l=r.callback;if(doWrite(e,t,!1,t.objectMode?1:f.length,f,u,l),r=r.next,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequestCount=0,t.bufferedRequest=r,t.bufferProcessing=!1}function needFinish(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function callFinal(e,t){e._final(function(r){t.pendingcb--,r&&e.emit("error",r),t.prefinished=!0,e.emit("prefinish"),finishMaybe(e,t)})}function prefinish(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,processNextTick(callFinal,e,t)):(t.prefinished=!0,e.emit("prefinish")))}function finishMaybe(e,t){var r=needFinish(t);return r&&(prefinish(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),r}function endWritable(e,t,r){t.ending=!0,finishMaybe(e,t),r&&(t.finished?processNextTick(r):e.once("finish",r)),t.ended=!0,e.writable=!1}function onCorkedFinish(e,t,r){var i=e.entry;for(e.entry=null;i;){var n=i.callback;t.pendingcb--,n(r),i=i.next}t.corkedRequestsFree?t.corkedRequestsFree.next=e:t.corkedRequestsFree=e}var processNextTick=require("process-nextick-args");module.exports=Writable;var asyncWrite=!process.browser&&["v0.10","v0.9."].indexOf(process.version.slice(0,5))>-1?setImmediate:processNextTick,Duplex;Writable.WritableState=WritableState;var util=require("core-util-is");util.inherits=require("inherits");var internalUtil={deprecate:require("util-deprecate")},Stream=require("./internal/streams/stream"),Buffer=require("safe-buffer").Buffer,OurUint8Array=global.Uint8Array||function(){},destroyImpl=require("./internal/streams/destroy");util.inherits(Writable,Stream),WritableState.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(WritableState.prototype,"buffer",{get:internalUtil.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}();var realHasInstance;"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(realHasInstance=Function.prototype[Symbol.hasInstance],Object.defineProperty(Writable,Symbol.hasInstance,{value:function(e){return!!realHasInstance.call(this,e)||e&&e._writableState instanceof WritableState}})):realHasInstance=function(e){return e instanceof this},Writable.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},Writable.prototype.write=function(e,t,r){var i=this._writableState,n=!1,o=_isUint8Array(e)&&!i.objectMode;return o&&!Buffer.isBuffer(e)&&(e=_uint8ArrayToBuffer(e)),"function"==typeof t&&(r=t,t=null),o?t="buffer":t||(t=i.defaultEncoding),"function"!=typeof r&&(r=nop),i.ended?writeAfterEnd(this,r):(o||validChunk(this,i,e,r))&&(i.pendingcb++,n=writeOrBuffer(this,i,o,e,t,r)),n},Writable.prototype.cork=function(){this._writableState.corked++},Writable.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,e.writing||e.corked||e.finished||e.bufferProcessing||!e.bufferedRequest||clearBuffer(this,e))},Writable.prototype.setDefaultEncoding=function(e){if("string"==typeof e&&(e=e.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((e+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Writable.prototype._write=function(e,t,r){r(new Error("_write() is not implemented"))},Writable.prototype._writev=null,Writable.prototype.end=function(e,t,r){var i=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!==e&&void 0!==e&&this.write(e,t),i.corked&&(i.corked=1,this.uncork()),i.ending||i.finished||endWritable(this,i,r)},Object.defineProperty(Writable.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),Writable.prototype.destroy=destroyImpl.destroy,Writable.prototype._undestroy=destroyImpl.undestroy,Writable.prototype._destroy=function(e,t){this.end(),t(e)};
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":84,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":48,"inherits":78,"process-nextick-args":81,"safe-buffer":97,"util-deprecate":102}],89:[function(require,module,exports){
+},{"./_stream_duplex":84,"./internal/streams/destroy":90,"./internal/streams/stream":91,"_process":82,"core-util-is":49,"inherits":78,"process-nextick-args":81,"safe-buffer":96,"util-deprecate":102}],89:[function(require,module,exports){
 "use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function copyBuffer(t,e,h){t.copy(e,h)}var Buffer=require("safe-buffer").Buffer;module.exports=function(){function t(){_classCallCheck(this,t),this.head=null,this.tail=null,this.length=0}return t.prototype.push=function(t){var e={data:t,next:null};this.length>0?this.tail.next=e:this.head=e,this.tail=e,++this.length},t.prototype.unshift=function(t){var e={data:t,next:this.head};0===this.length&&(this.tail=e),this.head=e,++this.length},t.prototype.shift=function(){if(0!==this.length){var t=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,t}},t.prototype.clear=function(){this.head=this.tail=null,this.length=0},t.prototype.join=function(t){if(0===this.length)return"";for(var e=this.head,h=""+e.data;e=e.next;)h+=t+e.data;return h},t.prototype.concat=function(t){if(0===this.length)return Buffer.alloc(0);if(1===this.length)return this.head.data;for(var e=Buffer.allocUnsafe(t>>>0),h=this.head,n=0;h;)copyBuffer(h.data,e,n),n+=h.data.length,h=h.next;return e},t}();
 
-},{"safe-buffer":97}],90:[function(require,module,exports){
+},{"safe-buffer":96}],90:[function(require,module,exports){
 "use strict";function destroy(t,e){var r=this,i=this._readableState&&this._readableState.destroyed,a=this._writableState&&this._writableState.destroyed;if(i||a)return void(e?e(t):!t||this._writableState&&this._writableState.errorEmitted||processNextTick(emitErrorNT,this,t));this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(t||null,function(t){!e&&t?(processNextTick(emitErrorNT,r,t),r._writableState&&(r._writableState.errorEmitted=!0)):e&&e(t)})}function undestroy(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)}function emitErrorNT(t,e){t.emit("error",e)}var processNextTick=require("process-nextick-args");module.exports={destroy:destroy,undestroy:undestroy};
 
 },{"process-nextick-args":81}],91:[function(require,module,exports){
 module.exports=require("events").EventEmitter;
 
-},{"events":49}],92:[function(require,module,exports){
-"use strict";function _normalizeEncoding(t){if(!t)return"utf8";for(var e;;)switch(t){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return t;default:if(e)return;t=(""+t).toLowerCase(),e=!0}}function normalizeEncoding(t){var e=_normalizeEncoding(t);if("string"!=typeof e&&(Buffer.isEncoding===isEncoding||!isEncoding(t)))throw new Error("Unknown encoding: "+t);return e||t}function StringDecoder(t){this.encoding=normalizeEncoding(t);var e;switch(this.encoding){case"utf16le":this.text=utf16Text,this.end=utf16End,e=4;break;case"utf8":this.fillLast=utf8FillLast,e=4;break;case"base64":this.text=base64Text,this.end=base64End,e=3;break;default:return this.write=simpleWrite,void(this.end=simpleEnd)}this.lastNeed=0,this.lastTotal=0,this.lastChar=Buffer.allocUnsafe(e)}function utf8CheckByte(t){return t<=127?0:t>>5==6?2:t>>4==14?3:t>>3==30?4:-1}function utf8CheckIncomplete(t,e,s){var i=e.length-1;if(i<s)return 0;var a=utf8CheckByte(e[i]);return a>=0?(a>0&&(t.lastNeed=a-1),a):--i<s?0:(a=utf8CheckByte(e[i]))>=0?(a>0&&(t.lastNeed=a-2),a):--i<s?0:(a=utf8CheckByte(e[i]),a>=0?(a>0&&(2===a?a=0:t.lastNeed=a-3),a):0)}function utf8CheckExtraBytes(t,e,s){if(128!=(192&e[0]))return t.lastNeed=0,"�".repeat(s);if(t.lastNeed>1&&e.length>1){if(128!=(192&e[1]))return t.lastNeed=1,"�".repeat(s+1);if(t.lastNeed>2&&e.length>2&&128!=(192&e[2]))return t.lastNeed=2,"�".repeat(s+2)}}function utf8FillLast(t){var e=this.lastTotal-this.lastNeed,s=utf8CheckExtraBytes(this,t,e);return void 0!==s?s:this.lastNeed<=t.length?(t.copy(this.lastChar,e,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(t.copy(this.lastChar,e,0,t.length),void(this.lastNeed-=t.length))}function utf8Text(t,e){var s=utf8CheckIncomplete(this,t,e);if(!this.lastNeed)return t.toString("utf8",e);this.lastTotal=s;var i=t.length-(s-this.lastNeed);return t.copy(this.lastChar,0,i),t.toString("utf8",e,i)}function utf8End(t){var e=t&&t.length?this.write(t):"";return this.lastNeed?e+"�".repeat(this.lastTotal-this.lastNeed):e}function utf16Text(t,e){if((t.length-e)%2==0){var s=t.toString("utf16le",e);if(s){var i=s.charCodeAt(s.length-1);if(i>=55296&&i<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1],s.slice(0,-1)}return s}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=t[t.length-1],t.toString("utf16le",e,t.length-1)}function utf16End(t){var e=t&&t.length?this.write(t):"";if(this.lastNeed){var s=this.lastTotal-this.lastNeed;return e+this.lastChar.toString("utf16le",0,s)}return e}function base64Text(t,e){var s=(t.length-e)%3;return 0===s?t.toString("base64",e):(this.lastNeed=3-s,this.lastTotal=3,1===s?this.lastChar[0]=t[t.length-1]:(this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1]),t.toString("base64",e,t.length-s))}function base64End(t){var e=t&&t.length?this.write(t):"";return this.lastNeed?e+this.lastChar.toString("base64",0,3-this.lastNeed):e}function simpleWrite(t){return t.toString(this.encoding)}function simpleEnd(t){return t&&t.length?this.write(t):""}var Buffer=require("safe-buffer").Buffer,isEncoding=Buffer.isEncoding||function(t){switch((t=""+t)&&t.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};exports.StringDecoder=StringDecoder,StringDecoder.prototype.write=function(t){if(0===t.length)return"";var e,s;if(this.lastNeed){if(void 0===(e=this.fillLast(t)))return"";s=this.lastNeed,this.lastNeed=0}else s=0;return s<t.length?e?e+this.text(t,s):this.text(t,s):e||""},StringDecoder.prototype.end=utf8End,StringDecoder.prototype.text=utf8Text,StringDecoder.prototype.fillLast=function(t){if(this.lastNeed<=t.length)return t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,t.length),this.lastNeed-=t.length};
-
-},{"safe-buffer":97}],93:[function(require,module,exports){
+},{"events":50}],92:[function(require,module,exports){
 module.exports=require("./readable").PassThrough;
 
-},{"./readable":94}],94:[function(require,module,exports){
+},{"./readable":93}],93:[function(require,module,exports){
 exports=module.exports=require("./lib/_stream_readable.js"),exports.Stream=exports,exports.Readable=exports,exports.Writable=require("./lib/_stream_writable.js"),exports.Duplex=require("./lib/_stream_duplex.js"),exports.Transform=require("./lib/_stream_transform.js"),exports.PassThrough=require("./lib/_stream_passthrough.js");
 
-},{"./lib/_stream_duplex.js":84,"./lib/_stream_passthrough.js":85,"./lib/_stream_readable.js":86,"./lib/_stream_transform.js":87,"./lib/_stream_writable.js":88}],95:[function(require,module,exports){
+},{"./lib/_stream_duplex.js":84,"./lib/_stream_passthrough.js":85,"./lib/_stream_readable.js":86,"./lib/_stream_transform.js":87,"./lib/_stream_writable.js":88}],94:[function(require,module,exports){
 module.exports=require("./readable").Transform;
 
-},{"./readable":94}],96:[function(require,module,exports){
+},{"./readable":93}],95:[function(require,module,exports){
 module.exports=require("./lib/_stream_writable.js");
 
-},{"./lib/_stream_writable.js":88}],97:[function(require,module,exports){
+},{"./lib/_stream_writable.js":88}],96:[function(require,module,exports){
 function copyProps(f,r){for(var e in f)r[e]=f[e]}function SafeBuffer(f,r,e){return Buffer(f,r,e)}var buffer=require("buffer"),Buffer=buffer.Buffer;Buffer.from&&Buffer.alloc&&Buffer.allocUnsafe&&Buffer.allocUnsafeSlow?module.exports=buffer:(copyProps(buffer,exports),exports.Buffer=SafeBuffer),copyProps(Buffer,SafeBuffer),SafeBuffer.from=function(f,r,e){if("number"==typeof f)throw new TypeError("Argument must not be a number");return Buffer(f,r,e)},SafeBuffer.alloc=function(f,r,e){if("number"!=typeof f)throw new TypeError("Argument must be a number");var u=Buffer(f);return void 0!==r?"string"==typeof e?u.fill(r,e):u.fill(r):u.fill(0),u},SafeBuffer.allocUnsafe=function(f){if("number"!=typeof f)throw new TypeError("Argument must be a number");return Buffer(f)},SafeBuffer.allocUnsafeSlow=function(f){if("number"!=typeof f)throw new TypeError("Argument must be a number");return buffer.SlowBuffer(f)};
 
-},{"buffer":47}],98:[function(require,module,exports){
+},{"buffer":48}],97:[function(require,module,exports){
 function Stream(){EE.call(this)}module.exports=Stream;var EE=require("events").EventEmitter,inherits=require("inherits");inherits(Stream,EE),Stream.Readable=require("readable-stream/readable.js"),Stream.Writable=require("readable-stream/writable.js"),Stream.Duplex=require("readable-stream/duplex.js"),Stream.Transform=require("readable-stream/transform.js"),Stream.PassThrough=require("readable-stream/passthrough.js"),Stream.Stream=Stream,Stream.prototype.pipe=function(e,r){function t(r){e.writable&&!1===e.write(r)&&m.pause&&m.pause()}function n(){m.readable&&m.resume&&m.resume()}function a(){u||(u=!0,e.end())}function o(){u||(u=!0,"function"==typeof e.destroy&&e.destroy())}function i(e){if(s(),0===EE.listenerCount(this,"error"))throw e}function s(){m.removeListener("data",t),e.removeListener("drain",n),m.removeListener("end",a),m.removeListener("close",o),m.removeListener("error",i),e.removeListener("error",i),m.removeListener("end",s),m.removeListener("close",s),e.removeListener("close",s)}var m=this;m.on("data",t),e.on("drain",n),e._isStdio||r&&!1===r.end||(m.on("end",a),m.on("close",o));var u=!1;return m.on("error",i),e.on("error",i),m.on("end",s),m.on("close",s),e.on("close",s),e.emit("pipe",m),e};
-},{"events":49,"inherits":78,"readable-stream/duplex.js":83,"readable-stream/passthrough.js":93,"readable-stream/readable.js":94,"readable-stream/transform.js":95,"readable-stream/writable.js":96}],99:[function(require,module,exports){
+},{"events":50,"inherits":78,"readable-stream/duplex.js":83,"readable-stream/passthrough.js":92,"readable-stream/readable.js":93,"readable-stream/transform.js":94,"readable-stream/writable.js":95}],98:[function(require,module,exports){
+"use strict";function _normalizeEncoding(t){if(!t)return"utf8";for(var e;;)switch(t){case"utf8":case"utf-8":return"utf8";case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return"utf16le";case"latin1":case"binary":return"latin1";case"base64":case"ascii":case"hex":return t;default:if(e)return;t=(""+t).toLowerCase(),e=!0}}function normalizeEncoding(t){var e=_normalizeEncoding(t);if("string"!=typeof e&&(Buffer.isEncoding===isEncoding||!isEncoding(t)))throw new Error("Unknown encoding: "+t);return e||t}function StringDecoder(t){this.encoding=normalizeEncoding(t);var e;switch(this.encoding){case"utf16le":this.text=utf16Text,this.end=utf16End,e=4;break;case"utf8":this.fillLast=utf8FillLast,e=4;break;case"base64":this.text=base64Text,this.end=base64End,e=3;break;default:return this.write=simpleWrite,void(this.end=simpleEnd)}this.lastNeed=0,this.lastTotal=0,this.lastChar=Buffer.allocUnsafe(e)}function utf8CheckByte(t){return t<=127?0:t>>5==6?2:t>>4==14?3:t>>3==30?4:-1}function utf8CheckIncomplete(t,e,s){var i=e.length-1;if(i<s)return 0;var a=utf8CheckByte(e[i]);return a>=0?(a>0&&(t.lastNeed=a-1),a):--i<s?0:(a=utf8CheckByte(e[i]))>=0?(a>0&&(t.lastNeed=a-2),a):--i<s?0:(a=utf8CheckByte(e[i]),a>=0?(a>0&&(2===a?a=0:t.lastNeed=a-3),a):0)}function utf8CheckExtraBytes(t,e,s){if(128!=(192&e[0]))return t.lastNeed=0,"�".repeat(s);if(t.lastNeed>1&&e.length>1){if(128!=(192&e[1]))return t.lastNeed=1,"�".repeat(s+1);if(t.lastNeed>2&&e.length>2&&128!=(192&e[2]))return t.lastNeed=2,"�".repeat(s+2)}}function utf8FillLast(t){var e=this.lastTotal-this.lastNeed,s=utf8CheckExtraBytes(this,t,e);return void 0!==s?s:this.lastNeed<=t.length?(t.copy(this.lastChar,e,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(t.copy(this.lastChar,e,0,t.length),void(this.lastNeed-=t.length))}function utf8Text(t,e){var s=utf8CheckIncomplete(this,t,e);if(!this.lastNeed)return t.toString("utf8",e);this.lastTotal=s;var i=t.length-(s-this.lastNeed);return t.copy(this.lastChar,0,i),t.toString("utf8",e,i)}function utf8End(t){var e=t&&t.length?this.write(t):"";return this.lastNeed?e+"�".repeat(this.lastTotal-this.lastNeed):e}function utf16Text(t,e){if((t.length-e)%2==0){var s=t.toString("utf16le",e);if(s){var i=s.charCodeAt(s.length-1);if(i>=55296&&i<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1],s.slice(0,-1)}return s}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=t[t.length-1],t.toString("utf16le",e,t.length-1)}function utf16End(t){var e=t&&t.length?this.write(t):"";if(this.lastNeed){var s=this.lastTotal-this.lastNeed;return e+this.lastChar.toString("utf16le",0,s)}return e}function base64Text(t,e){var s=(t.length-e)%3;return 0===s?t.toString("base64",e):(this.lastNeed=3-s,this.lastTotal=3,1===s?this.lastChar[0]=t[t.length-1]:(this.lastChar[0]=t[t.length-2],this.lastChar[1]=t[t.length-1]),t.toString("base64",e,t.length-s))}function base64End(t){var e=t&&t.length?this.write(t):"";return this.lastNeed?e+this.lastChar.toString("base64",0,3-this.lastNeed):e}function simpleWrite(t){return t.toString(this.encoding)}function simpleEnd(t){return t&&t.length?this.write(t):""}var Buffer=require("safe-buffer").Buffer,isEncoding=Buffer.isEncoding||function(t){switch((t=""+t)&&t.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};exports.StringDecoder=StringDecoder,StringDecoder.prototype.write=function(t){if(0===t.length)return"";var e,s;if(this.lastNeed){if(void 0===(e=this.fillLast(t)))return"";s=this.lastNeed,this.lastNeed=0}else s=0;return s<t.length?e?e+this.text(t,s):this.text(t,s):e||""},StringDecoder.prototype.end=utf8End,StringDecoder.prototype.text=utf8Text,StringDecoder.prototype.fillLast=function(t){if(this.lastNeed<=t.length)return t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);t.copy(this.lastChar,this.lastTotal-this.lastNeed,0,t.length),this.lastNeed-=t.length};
+},{"safe-buffer":96}],99:[function(require,module,exports){
 "use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var n=0;n<e.length;n++){var r=e[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(e,n,r){return n&&t(e.prototype,n),r&&t(e,r),e}}(),_=require("./"),_2=_interopRequireDefault(_),Block=function(){function t(e,n){_classCallCheck(this,t),this.index=0,this.thaws=[],this.count=n||200,this.options=e}return _createClass(t,[{key:"add",value:function(t){return this._next().add(t),this}},{key:"addArray",value:function(t){return this._next().addArray(t),this}},{key:"insert",value:function(t){return this._next().insert(t),this}},{key:"insertArray",value:function(t){return this._next().insertArray(t),this}},{key:"stop",value:function(){for(var t=0;t<this.thaws.length;t++)this.thaws[t].stop();return this}},{key:"_next",value:function(){var t=null,e=this.thaws;return e.length<this.count?e.push(t=new _2.default([],this.options)):t=e[this.index],this.index++,this.index>=this.count&&(this.index=0),t}}]),t}();exports.default=Block;
 
 },{"./":100}],100:[function(require,module,exports){
 "use strict";function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(exports,"__esModule",{value:!0}),exports.Block=void 0;var _thaw=require("./thaw"),_thaw2=_interopRequireDefault(_thaw),_block=require("./block"),_block2=_interopRequireDefault(_block);exports.default=_thaw2.default,exports.Block=_block2.default,"undefined"!=typeof window&&(window.Thaw=_thaw2.default,window.Thaw.Block=_block2.default);
-
 },{"./block":99,"./thaw":101}],101:[function(require,module,exports){
 "use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function thaw(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return new Thaw(t,e)}Object.defineProperty(exports,"__esModule",{value:!0});var _extends=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var i=arguments[e];for(var n in i)Object.prototype.hasOwnProperty.call(i,n)&&(t[n]=i[n])}return t},_createClass=function(){function t(t,e){for(var i=0;i<e.length;i++){var n=e[i];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}return function(e,i,n){return i&&t(e.prototype,i),n&&t(e,n),e}}();exports.thaw=thaw;var thawing=!1,thaws=[],Thaw=function(){function t(e){var i=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};_classCallCheck(this,t);var s=_extends({},this.constructor.defaultSettings,n),a=s.each,r=s.done;this.items=e,this.i=0,this.options=n;var h=this.tick=function(){if(!(i.i<0||(i.timeout=setTimeout(h,0),thawing))){var t=e[i.i];if(i.i>=e.length)return null!==r&&(thawing=!0,r(t,i.i),thawing=!1),i.i=-1,void clearTimeout(i.timeout);null!==a?(thawing=!0,a(t,i.i),thawing=!1):void 0!==t&&t(),i.i++}};thaws.push(this),n.delay||h()}return _createClass(t,null,[{key:"stopAll",value:function(){for(var t=0;t<thaws.length;t++)thaws[t].stop()}},{key:"defaultSettings",get:function(){return{each:null,done:null}}},{key:"isThawing",get:function(){return thawing}}]),_createClass(t,[{key:"makeReady",value:function(){return this.i<0&&(this.i=this.items.length,!0)}},{key:"add",value:function(t){var e=this.makeReady();return this.items.push(t),e&&this.tick(),this}},{key:"insert",value:function(t){var e=this.makeReady();return this.items.splice(this.i,0,t),e&&this.tick(),this}},{key:"addArray",value:function(t){var e=this.makeReady();return this.items=this.items.concat(t),e&&this.tick(),this}},{key:"insertArray",value:function(t){var e=this.makeReady(),i=this.items,n=t,s=this.items.splice(this.i,this.items.length-this.i+1);return this.items=i.concat(n,s),e&&this.tick(),this}},{key:"stop",value:function(){return this.i=-1,clearTimeout(this.timeout),this.options.done&&this.options.done(),this}}]),t}();exports.default=Thaw;
 
diff --git a/dist/neural-network.js b/dist/neural-network.js
index 004d9a967..1311d5927 100644
--- a/dist/neural-network.js
+++ b/dist/neural-network.js
@@ -57,24 +57,24 @@ var NeuralNetwork = function () {
     key: 'trainDefaults',
     get: function get() {
       return {
-        iterations: 20000,
-        errorThresh: 0.005,
-        log: false,
-        logPeriod: 10,
-        learningRate: 0.3,
-        callback: null,
-        callbackPeriod: 10
+        iterations: 20000, // the maximum times to iterate the training data
+        errorThresh: 0.005, // the acceptable error percentage from training data
+        log: false, // true to use console.log, when a function is supplied it is used
+        logPeriod: 10, // iterations between logging out
+        learningRate: 0.3, // multiply's against the input and the delta then adds to momentum
+        momentum: 0.1, // multiply's against the specified "change" then adds to learning rate for change
+        callback: null, // a periodic call back that can be triggered while training
+        callbackPeriod: 10, // the number of iterations through the training data between callback calls
+        timeout: Infinity // the max number of milliseconds to train for
       };
     }
   }, {
     key: 'defaults',
     get: function get() {
       return {
-        learningRate: 0.3,
-        momentum: 0.1,
-        binaryThresh: 0.5,
-        hiddenLayers: null,
-        activation: 'sigmoid'
+        binaryThresh: 0.5, // ¯\_(ツ)_/¯
+        hiddenLayers: [3], // array of ints for the sizes of the hidden layers in the network
+        activation: 'sigmoid' // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']
       };
     }
   }]);
@@ -86,6 +86,8 @@ var NeuralNetwork = function () {
 
     Object.assign(this, this.constructor.defaults, options);
     this.hiddenSizes = options.hiddenLayers;
+    this.trainOpts = {};
+    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));
 
     this.sizes = null;
     this.outputLayer = null;
@@ -108,14 +110,15 @@ var NeuralNetwork = function () {
 
   /**
    *
-   * @param {Number[]} sizes
+   * Expects this.sizes to have been set
    */
 
 
   _createClass(NeuralNetwork, [{
-    key: 'initialize',
-    value: function initialize(sizes) {
-      this.sizes = sizes;
+    key: '_initialize',
+    value: function _initialize() {
+      if (!this.sizes) throw new Error('Sizes must be set before initializing');
+
       this.outputLayer = this.sizes.length - 1;
       this.biases = []; // weights for bias nodes
       this.weights = [];
@@ -147,9 +150,16 @@ var NeuralNetwork = function () {
 
       this.setActivation();
     }
+
+    /**
+     *
+     * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+     */
+
   }, {
     key: 'setActivation',
-    value: function setActivation() {
+    value: function setActivation(activation) {
+      this.activation = activation ? activation : this.activation;
       switch (this.activation) {
         case 'sigmoid':
           this.runInput = this.runInput || this.runInputSigmoid;
@@ -294,27 +304,114 @@ var NeuralNetwork = function () {
     /**
      *
      * @param data
-     * @returns sizes
+     * Verifies network sizes are initilaized
+     * If they are not it will initialize them based off the data set.
      */
 
   }, {
-    key: '_getSizesFromData',
-    value: function _getSizesFromData(data) {
-      var sizes = [];
-      var inputSize = data[0].input.length;
-      var outputSize = data[0].output.length;
-      var hiddenSizes = this.hiddenSizes;
-      if (!hiddenSizes) {
-        sizes.push(Math.max(3, Math.floor(inputSize / 2)));
+    key: '_verifyIsInitialized',
+    value: function _verifyIsInitialized(data) {
+      var _this = this;
+
+      if (this.sizes) return;
+
+      this.sizes = [];
+      this.sizes.push(data[0].input.length);
+      if (!this.hiddenSizes) {
+        this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));
       } else {
-        hiddenSizes.forEach(function (size) {
-          sizes.push(size);
+        this.hiddenSizes.forEach(function (size) {
+          _this.sizes.push(size);
         });
       }
+      this.sizes.push(data[0].output.length);
+
+      this._initialize();
+    }
+
+    /**
+     *
+     * @param options
+     *    Supports all `trainDefaults` properties
+     *    also supports:
+     *       learningRate: (number),
+     *       momentum: (number),
+     *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']
+     */
 
-      sizes.unshift(inputSize);
-      sizes.push(outputSize);
-      return sizes;
+  }, {
+    key: 'updateTrainingOptions',
+    value: function updateTrainingOptions(opts) {
+      if (opts.iterations) {
+        this.trainOpts.iterations = opts.iterations;
+      }
+      if (opts.errorThresh) {
+        this.trainOpts.errorThresh = opts.errorThresh;
+      }
+      if (opts.log) {
+        this._setLogMethod(opts.log);
+      }
+      if (opts.logPeriod) {
+        this.trainOpts.logPeriod = opts.logPeriod;
+      }
+      if (opts.learningRate) {
+        this.trainOpts.learningRate = opts.learningRate;
+      }
+      if (opts.momentum) {
+        this.trainOpts.momentum = opts.momentum;
+      }
+      if (opts.callback) {
+        this.trainOpts.callback = opts.callback;
+      }
+      if (opts.callbackPeriod) {
+        this.trainOpts.callbackPeriod = opts.callbackPeriod;
+      }
+      if (opts.timeout) {
+        this.trainOpts.timeout = opts.timeout;
+      }
+      if (opts.activation) {
+        this.activation = opts.activation;
+      }
+    }
+
+    /**
+     *
+     *  Gets JSON of trainOpts object
+     *    NOTE: Activation is stored directly on JSON object and not in the training options
+     */
+
+  }, {
+    key: '_getTrainOptsJSON',
+    value: function _getTrainOptsJSON() {
+      var results = {};
+      if (this.trainOpts.iterations) {
+        results.iterations = this.trainOpts.iterations;
+      }
+      if (this.trainOpts.errorThresh) {
+        results.errorThresh = this.trainOpts.errorThresh;
+      }
+      if (this.trainOpts.logPeriod) {
+        results.logPeriod = this.trainOpts.logPeriod;
+      }
+      if (this.trainOpts.learningRate) {
+        results.learningRate = this.trainOpts.learningRate;
+      }
+      if (this.trainOpts.momentum) {
+        results.momentum = this.trainOpts.momentum;
+      }
+      if (this.trainOpts.callback) {
+        results.callback = this.trainOpts.callback;
+      }
+      if (this.trainOpts.callbackPeriod) {
+        results.callbackPeriod = this.trainOpts.callbackPeriod;
+      }
+      if (this.trainOpts.timeout) {
+        results.timeout = this.trainOpts.timeout;
+      }
+      if (this.trainOpts.log) {
+        results.log = true;
+      }
+      return results;
     }
 
     /**
@@ -328,8 +425,13 @@ var NeuralNetwork = function () {
   }, {
     key: '_setLogMethod',
     value: function _setLogMethod(log) {
-      if (log) return console.log;
-      return false;
+      if (typeof log === 'function') {
+        this.trainOpts.log = log;
+      } else if (log) {
+        this.trainOpts.log = console.log;
+      } else {
+        this.trainOpts.log = false;
+      }
     }
 
     /**
@@ -341,10 +443,10 @@ var NeuralNetwork = function () {
 
   }, {
     key: '_calculateTrainingError',
-    value: function _calculateTrainingError(data, learningRate) {
+    value: function _calculateTrainingError(data) {
       var sum = 0;
       for (var i = 0; i < data.length; ++i) {
-        sum += this.trainPattern(data[i].input, data[i].output, learningRate);
+        sum += this._trainPattern(data[i].input, data[i].output);
       }
       return sum / data.length;
     }
@@ -356,48 +458,45 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: '_checkTrainingTick',
-    value: function _checkTrainingTick(data, status, options) {
+    key: '_trainingTick',
+    value: function _trainingTick(data, status) {
       status.iterations++;
-      status.error = this._calculateTrainingError(data, options.learningRate);
+      status.error = this._calculateTrainingError(data);
 
-      if (options.log && status.iterations % options.logPeriod === 0) {
-        options.log('iterations: ' + status.iterations + ', training error: ' + status.error);
+      if (this.trainOpts.log && status.iterations % this.trainOpts.logPeriod === 0) {
+        this.trainOpts.log('iterations: ' + status.iterations + ', training error: ' + status.error);
       }
 
-      if (options.callback && status.iterations % options.callbackPeriod === 0) {
-        options.callback(Object.assign(status));
+      if (this.trainOpts.callback && status.iterations % this.trainOpts.callbackPeriod === 0) {
+        this.trainOpts.callback(Object.assign(status));
       }
     }
 
     /**
      *
      * @param data
-     * @param _options
+     * @param options
      * @returns {{error: number, iterations: number}}
      */
 
   }, {
     key: 'train',
     value: function train(data) {
-      var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-      var options = Object.assign({}, this.constructor.trainDefaults, _options);
+      this.updateTrainingOptions(options);
       data = this.formatData(data);
-      options.log = this._setLogMethod(options.log);
-      options.learningRate = _options.learningRate || this.learningRate || options.learningRate;
+      var endTime = Date.now() + this.trainOpts.timeout;
+
       var status = {
         error: 1,
         iterations: 0
       };
 
-      if (this.sizes === null) {
-        var sizes = this._getSizesFromData(data);
-        this.initialize(sizes);
-      }
+      this._verifyIsInitialized(data);
 
-      while (status.iterations < options.iterations && status.error > options.errorThresh) {
-        this._checkTrainingTick(data, status, options);
+      while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {
+        this._trainingTick(data, status);
       }
 
       return status;
@@ -406,7 +505,7 @@ var NeuralNetwork = function () {
     /**
      *
      * @param data
-     * @param _options
+     * @param options
      * @param cb
      * @returns {{error: number, iterations: number}}
      */
@@ -414,34 +513,28 @@ var NeuralNetwork = function () {
   }, {
     key: 'trainAsync',
     value: function trainAsync(data) {
-      var _this = this;
+      var _this2 = this;
 
-      var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       return new Promise(function (resolve, reject) {
-        var options = Object.assign({}, _this.constructor.trainDefaults, _options);
-        data = _this.formatData(data);
-        options.log = _this._setLogMethod(options.log);
-        options.learningRate = _options.learningRate || _this.learningRate || options.learningRate;
-        var endTime = Date.now() + options.trainTimeMs;
+        _this2.updateTrainingOptions(options);
+        data = _this2.formatData(data);
+        var endTime = Date.now() + _this2.trainOpts.timeout;
 
         var status = {
           error: 1,
           iterations: 0
         };
 
-        if (_this.sizes === null) {
-          var sizes = _this._getSizesFromData(data);
-          _this.initialize(sizes);
-        }
+        _this2._verifyIsInitialized(data);
 
-        var items = new Array(options.iterations);
+        var items = new Array(_this2.trainOpts.iterations);
         var thaw = new _thaw2.default(items, {
           delay: true,
           each: function each() {
-            _this._checkTrainingTick(data, status, options);
-
-            if (status.error < options.errorThresh) {
+            _this2._trainingTick(data, status);
+            if (status.error < _this2.trainOpts.errorThresh || Date.now() > endTime) {
               thaw.stop();
             }
           },
@@ -458,20 +551,18 @@ var NeuralNetwork = function () {
      *
      * @param input
      * @param target
-     * @param learningRate
      */
 
   }, {
-    key: 'trainPattern',
-    value: function trainPattern(input, target, learningRate) {
-      learningRate = learningRate || this.learningRate;
+    key: '_trainPattern',
+    value: function _trainPattern(input, target) {
 
       // forward propagate
       this.runInput(input);
 
       // back propagate
       this.calculateDeltas(target);
-      this.adjustWeights(learningRate);
+      this.adjustWeights();
 
       var error = (0, _mse2.default)(this.errors[this.outputLayer]);
       return error;
@@ -587,12 +678,12 @@ var NeuralNetwork = function () {
 
     /**
      *
-     * @param learningRate
+     * Changes weights of networks
      */
 
   }, {
     key: 'adjustWeights',
-    value: function adjustWeights(learningRate) {
+    value: function adjustWeights() {
       for (var layer = 1; layer <= this.outputLayer; layer++) {
         var incoming = this.outputs[layer - 1];
 
@@ -602,12 +693,12 @@ var NeuralNetwork = function () {
           for (var k = 0; k < incoming.length; k++) {
             var change = this.changes[layer][node][k];
 
-            change = learningRate * delta * incoming[k] + this.momentum * change;
+            change = this.trainOpts.learningRate * delta * incoming[k] + this.trainOpts.momentum * change;
 
             this.changes[layer][node][k] = change;
             this.weights[layer][node][k] += change;
           }
-          this.biases[layer][node] += learningRate * delta;
+          this.biases[layer][node] += this.trainOpts.learningRate * delta;
         }
       }
     }
@@ -621,7 +712,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'formatData',
     value: function formatData(data) {
-      var _this2 = this;
+      var _this3 = this;
 
       if (!Array.isArray(data)) {
         // turn stream datum into array
@@ -638,7 +729,7 @@ var NeuralNetwork = function () {
           }));
         }
         data = data.map(function (datum) {
-          var array = _lookup2.default.toArray(_this2.inputLookup, datum.input);
+          var array = _lookup2.default.toArray(_this3.inputLookup, datum.input);
           return Object.assign({}, datum, { input: array });
         }, this);
       }
@@ -650,7 +741,7 @@ var NeuralNetwork = function () {
           }));
         }
         data = data.map(function (datum) {
-          var array = _lookup2.default.toArray(_this2.outputLookup, datum.output);
+          var array = _lookup2.default.toArray(_this3.outputLookup, datum.output);
           return Object.assign({}, datum, { output: array });
         }, this);
       }
@@ -671,7 +762,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'test',
     value: function test(data) {
-      var _this3 = this;
+      var _this4 = this;
 
       data = this.formatData(data);
 
@@ -690,13 +781,13 @@ var NeuralNetwork = function () {
       var sum = 0;
 
       var _loop = function _loop(i) {
-        var output = _this3.runInput(data[i].input);
+        var output = _this4.runInput(data[i].input);
         var target = data[i].output;
 
         var actual = void 0,
             expected = void 0;
         if (isBinary) {
-          actual = output[0] > _this3.binaryThresh ? 1 : 0;
+          actual = output[0] > _this4.binaryThresh ? 1 : 0;
           expected = target[0];
         } else {
           actual = output.indexOf((0, _max2.default)(output));
@@ -831,7 +922,8 @@ var NeuralNetwork = function () {
         layers: layers,
         outputLookup: !!this.outputLookup,
         inputLookup: !!this.inputLookup,
-        activation: this.activation
+        activation: this.activation,
+        trainOpts: this._getTrainOptsJSON()
       };
     }
 
@@ -844,7 +936,8 @@ var NeuralNetwork = function () {
   }, {
     key: 'fromJSON',
     value: function fromJSON(json) {
-      this.initialize(json.sizes);
+      this.sizes = json.sizes;
+      this._initialize();
 
       for (var i = 0; i <= this.outputLayer; i++) {
         var layer = json.layers[i];
@@ -863,7 +956,7 @@ var NeuralNetwork = function () {
           }
         }
       }
-
+      this.updateTrainingOptions(json.trainOpts);
       this.setActivation();
       return this;
     }
@@ -941,7 +1034,7 @@ var NeuralNetwork = function () {
   }, {
     key: 'isRunnable',
     get: function get() {
-      var _this4 = this;
+      var _this5 = this;
 
       if (!this.runInput) {
         console.error('Activation function has not been initialized, did you run train()?');
@@ -949,7 +1042,7 @@ var NeuralNetwork = function () {
       }
 
       var checkFns = ['sizes', 'outputLayer', 'biases', 'weights', 'outputs', 'deltas', 'changes', 'errors'].filter(function (c) {
-        return _this4[c] === null;
+        return _this5[c] === null;
       });
 
       if (checkFns.length > 0) {
diff --git a/dist/neural-network.js.map b/dist/neural-network.js.map
index bdb1719bf..3e616a77b 100644
--- a/dist/neural-network.js.map
+++ b/dist/neural-network.js.map
@@ -1 +1 @@
-{"version":3,"sources":["../src/neural-network.js"],"names":["NeuralNetwork","iterations","errorThresh","log","logPeriod","learningRate","callback","callbackPeriod","momentum","binaryThresh","hiddenLayers","activation","options","Object","assign","constructor","defaults","hiddenSizes","sizes","outputLayer","biases","weights","outputs","deltas","changes","errors","prototype","hasOwnProperty","runInput","calculateDeltas","length","layer","size","Array","node","prevSize","setActivation","runInputSigmoid","calculateDeltasSigmoid","runInputRelu","calculateDeltasRelu","runInputLeakyRelu","calculateDeltasLeakyRelu","runInputTanh","calculateDeltasTanh","Error","input","isRunnable","inputLookup","toArray","output","outputLookup","toHash","sum","k","Math","exp","tanh","data","inputSize","outputSize","push","max","floor","forEach","unshift","console","i","trainPattern","status","error","_calculateTrainingError","_options","trainDefaults","formatData","_setLogMethod","_getSizesFromData","initialize","_checkTrainingTick","Promise","resolve","reject","endTime","Date","now","trainTimeMs","items","thaw","delay","each","stop","done","tick","target","adjustWeights","incoming","delta","change","isArray","tmp","datum","Float32Array","buildLookup","map","value","array","isBinary","falsePos","falseNeg","truePos","trueNeg","misclasses","actual","expected","indexOf","misclass","stats","total","precision","recall","accuracy","layers","nodes","keys","j","bias","index","json","lookupFromHash","nodeHandle","layerNumber","nodeKey","result","w","join","toJSON","layersAsMath","key","Function","opts","neuralNetwork","trainStream","checkFns","filter","c"],"mappings":";;;;;;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;AAEA;;;;IAIqBA,a;;;wBACQ;AACzB,aAAO;AACLC,oBAAY,KADP;AAELC,qBAAa,KAFR;AAGLC,aAAK,KAHA;AAILC,mBAAW,EAJN;AAKLC,sBAAc,GALT;AAMLC,kBAAU,IANL;AAOLC,wBAAgB;AAPX,OAAP;AASD;;;wBAEqB;AACpB,aAAO;AACLF,sBAAc,GADT;AAELG,kBAAU,GAFL;AAGLC,sBAAc,GAHT;AAILC,sBAAc,IAJT;AAKLC,oBAAY;AALP,OAAP;AAOD;;;AAED,2BAA0B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AACxBC,WAAOC,MAAP,CAAc,IAAd,EAAoB,KAAKC,WAAL,CAAiBC,QAArC,EAA+CJ,OAA/C;AACA,SAAKK,WAAL,GAAmBL,QAAQF,YAA3B;;AAEA,SAAKQ,KAAL,GAAa,IAAb;AACA,SAAKC,WAAL,GAAmB,IAAnB;AACA,SAAKC,MAAL,GAAc,IAAd,CANwB,CAMJ;AACpB,SAAKC,OAAL,GAAe,IAAf;AACA,SAAKC,OAAL,GAAe,IAAf;;AAEA;AACA,SAAKC,MAAL,GAAc,IAAd;AACA,SAAKC,OAAL,GAAe,IAAf,CAZwB,CAYH;AACrB,SAAKC,MAAL,GAAc,IAAd;;AAEA,QAAI,CAAC,KAAKV,WAAL,CAAiBW,SAAjB,CAA2BC,cAA3B,CAA0C,UAA1C,CAAL,EAA4D;AAC1D,WAAKC,QAAL,GAAgB,IAAhB;AACD;AACD,QAAI,CAAC,KAAKb,WAAL,CAAiBW,SAAjB,CAA2BC,cAA3B,CAA0C,iBAA1C,CAAL,EAAmE;AACjE,WAAKE,eAAL,GAAuB,IAAvB;AACD;AACF;;AAED;;;;;;;;+BAIWX,K,EAAO;AAChB,WAAKA,KAAL,GAAaA,KAAb;AACA,WAAKC,WAAL,GAAmB,KAAKD,KAAL,CAAWY,MAAX,GAAoB,CAAvC;AACA,WAAKV,MAAL,GAAc,EAAd,CAHgB,CAGE;AAClB,WAAKC,OAAL,GAAe,EAAf;AACA,WAAKC,OAAL,GAAe,EAAf;;AAEA;AACA,WAAKC,MAAL,GAAc,EAAd;AACA,WAAKC,OAAL,GAAe,EAAf,CATgB,CASG;AACnB,WAAKC,MAAL,GAAc,EAAd;;AAEA,WAAK,IAAIM,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,YAAIC,OAAO,KAAKd,KAAL,CAAWa,KAAX,CAAX;AACA,aAAKR,MAAL,CAAYQ,KAAZ,IAAqB,qBAAMC,IAAN,CAArB;AACA,aAAKP,MAAL,CAAYM,KAAZ,IAAqB,qBAAMC,IAAN,CAArB;AACA,aAAKV,OAAL,CAAaS,KAAb,IAAsB,qBAAMC,IAAN,CAAtB;;AAEA,YAAID,QAAQ,CAAZ,EAAe;AACb,eAAKX,MAAL,CAAYW,KAAZ,IAAqB,sBAAOC,IAAP,CAArB;AACA,eAAKX,OAAL,CAAaU,KAAb,IAAsB,IAAIE,KAAJ,CAAUD,IAAV,CAAtB;AACA,eAAKR,OAAL,CAAaO,KAAb,IAAsB,IAAIE,KAAJ,CAAUD,IAAV,CAAtB;;AAEA,eAAK,IAAIE,OAAO,CAAhB,EAAmBA,OAAOF,IAA1B,EAAgCE,MAAhC,EAAwC;AACtC,gBAAIC,WAAW,KAAKjB,KAAL,CAAWa,QAAQ,CAAnB,CAAf;AACA,iBAAKV,OAAL,CAAaU,KAAb,EAAoBG,IAApB,IAA4B,sBAAOC,QAAP,CAA5B;AACA,iBAAKX,OAAL,CAAaO,KAAb,EAAoBG,IAApB,IAA4B,qBAAMC,QAAN,CAA5B;AACD;AACF;AACF;;AAED,WAAKC,aAAL;AACD;;;oCAEe;AACd,cAAQ,KAAKzB,UAAb;AACE,aAAK,SAAL;AACE,eAAKiB,QAAL,GAAgB,KAAKA,QAAL,IAAiB,KAAKS,eAAtC;AACA,eAAKR,eAAL,GAAuB,KAAKA,eAAL,IAAwB,KAAKS,sBAApD;AACA;AACF,aAAK,MAAL;AACE,eAAKV,QAAL,GAAgB,KAAKA,QAAL,IAAiB,KAAKW,YAAtC;AACA,eAAKV,eAAL,GAAuB,KAAKA,eAAL,IAAwB,KAAKW,mBAApD;AACA;AACF,aAAK,YAAL;AACE,eAAKZ,QAAL,GAAgB,KAAKA,QAAL,IAAiB,KAAKa,iBAAtC;AACA,eAAKZ,eAAL,GAAuB,KAAKA,eAAL,IAAwB,KAAKa,wBAApD;AACA;AACF,aAAK,MAAL;AACE,eAAKd,QAAL,GAAgB,KAAKA,QAAL,IAAiB,KAAKe,YAAtC;AACA,eAAKd,eAAL,GAAuB,KAAKA,eAAL,IAAwB,KAAKe,mBAApD;AACA;AACF;AACE,gBAAM,IAAIC,KAAJ,CAAU,wBAAwB,KAAKlC,UAAvC,CAAN;AAlBJ;AAoBD;;AAED;;;;;;;;;AA6BA;;;;;wBAKImC,K,EAAO;AACT,UAAI,CAAC,KAAKC,UAAV,EAAsB,OAAO,IAAP;AACtB,UAAI,KAAKC,WAAT,EAAsB;AACpBF,gBAAQ,iBAAOG,OAAP,CAAe,KAAKD,WAApB,EAAiCF,KAAjC,CAAR;AACD;;AAED,UAAII,sCAAa,KAAKtB,QAAL,CAAckB,KAAd,CAAb,EAAJ;;AAEA,UAAI,KAAKK,YAAT,EAAuB;AACrBD,iBAAS,iBAAOE,MAAP,CAAc,KAAKD,YAAnB,EAAiCD,MAAjC,CAAT;AACD;AACD,aAAOA,MAAP;AACD;;AAED;;;;;;;;oCAKgBJ,K,EAAO;AACrB,WAAKxB,OAAL,CAAa,CAAb,IAAkBwB,KAAlB,CADqB,CACK;;AAE1B,UAAII,SAAS,IAAb;AACA,WAAK,IAAInB,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIb,UAAU,KAAKA,OAAL,CAAaU,KAAb,EAAoBG,IAApB,CAAd;;AAEA,cAAImB,MAAM,KAAKjC,MAAL,CAAYW,KAAZ,EAAmBG,IAAnB,CAAV;AACA,eAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIjC,QAAQS,MAA5B,EAAoCwB,GAApC,EAAyC;AACvCD,mBAAOhC,QAAQiC,CAAR,IAAaR,MAAMQ,CAAN,CAApB;AACD;AACD;AACA,eAAKhC,OAAL,CAAaS,KAAb,EAAoBG,IAApB,IAA4B,KAAK,IAAIqB,KAAKC,GAAL,CAAS,CAACH,GAAV,CAAT,CAA5B;AACD;AACDH,iBAASJ,QAAQ,KAAKxB,OAAL,CAAaS,KAAb,CAAjB;AACD;AACD,aAAOmB,MAAP;AACD;;;iCAEYJ,K,EAAO;AAClB,WAAKxB,OAAL,CAAa,CAAb,IAAkBwB,KAAlB,CADkB,CACQ;;AAE1B,UAAII,SAAS,IAAb;AACA,WAAK,IAAInB,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIb,UAAU,KAAKA,OAAL,CAAaU,KAAb,EAAoBG,IAApB,CAAd;;AAEA,cAAImB,MAAM,KAAKjC,MAAL,CAAYW,KAAZ,EAAmBG,IAAnB,CAAV;AACA,eAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIjC,QAAQS,MAA5B,EAAoCwB,GAApC,EAAyC;AACvCD,mBAAOhC,QAAQiC,CAAR,IAAaR,MAAMQ,CAAN,CAApB;AACD;AACD;AACA,eAAKhC,OAAL,CAAaS,KAAb,EAAoBG,IAApB,IAA6BmB,MAAM,CAAN,GAAU,CAAV,GAAcA,GAA3C;AACD;AACDH,iBAASJ,QAAQ,KAAKxB,OAAL,CAAaS,KAAb,CAAjB;AACD;AACD,aAAOmB,MAAP;AACD;;;sCAEiBJ,K,EAAO;AACvB,WAAKxB,OAAL,CAAa,CAAb,IAAkBwB,KAAlB,CADuB,CACG;;AAE1B,UAAII,SAAS,IAAb;AACA,WAAK,IAAInB,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIb,UAAU,KAAKA,OAAL,CAAaU,KAAb,EAAoBG,IAApB,CAAd;;AAEA,cAAImB,MAAM,KAAKjC,MAAL,CAAYW,KAAZ,EAAmBG,IAAnB,CAAV;AACA,eAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIjC,QAAQS,MAA5B,EAAoCwB,GAApC,EAAyC;AACvCD,mBAAOhC,QAAQiC,CAAR,IAAaR,MAAMQ,CAAN,CAApB;AACD;AACD;AACA,eAAKhC,OAAL,CAAaS,KAAb,EAAoBG,IAApB,IAA6BmB,MAAM,CAAN,GAAU,CAAV,GAAc,OAAOA,GAAlD;AACD;AACDH,iBAASJ,QAAQ,KAAKxB,OAAL,CAAaS,KAAb,CAAjB;AACD;AACD,aAAOmB,MAAP;AACD;;;iCAEYJ,K,EAAO;AAClB,WAAKxB,OAAL,CAAa,CAAb,IAAkBwB,KAAlB,CADkB,CACQ;;AAE1B,UAAII,SAAS,IAAb;AACA,WAAK,IAAInB,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIb,UAAU,KAAKA,OAAL,CAAaU,KAAb,EAAoBG,IAApB,CAAd;;AAEA,cAAImB,MAAM,KAAKjC,MAAL,CAAYW,KAAZ,EAAmBG,IAAnB,CAAV;AACA,eAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIjC,QAAQS,MAA5B,EAAoCwB,GAApC,EAAyC;AACvCD,mBAAOhC,QAAQiC,CAAR,IAAaR,MAAMQ,CAAN,CAApB;AACD;AACD;AACA,eAAKhC,OAAL,CAAaS,KAAb,EAAoBG,IAApB,IAA4BqB,KAAKE,IAAL,CAAUJ,GAAV,CAA5B;AACD;AACDH,iBAASJ,QAAQ,KAAKxB,OAAL,CAAaS,KAAb,CAAjB;AACD;AACD,aAAOmB,MAAP;AACD;;AAED;;;;;;;;sCAKkBQ,I,EAAM;AACtB,UAAIxC,QAAQ,EAAZ;AACA,UAAIyC,YAAYD,KAAK,CAAL,EAAQZ,KAAR,CAAchB,MAA9B;AACA,UAAI8B,aAAaF,KAAK,CAAL,EAAQR,MAAR,CAAepB,MAAhC;AACA,UAAIb,cAAc,KAAKA,WAAvB;AACA,UAAI,CAACA,WAAL,EAAkB;AAChBC,cAAM2C,IAAN,CAAWN,KAAKO,GAAL,CAAS,CAAT,EAAYP,KAAKQ,KAAL,CAAWJ,YAAY,CAAvB,CAAZ,CAAX;AACD,OAFD,MAEO;AACL1C,oBAAY+C,OAAZ,CAAoB,gBAAQ;AAC1B9C,gBAAM2C,IAAN,CAAW7B,IAAX;AACD,SAFD;AAGD;;AAEDd,YAAM+C,OAAN,CAAcN,SAAd;AACAzC,YAAM2C,IAAN,CAAWD,UAAX;AACA,aAAO1C,KAAP;AACD;;AAGD;;;;;;;;;;kCAOcf,G,EAAK;AACjB,UAAIA,GAAJ,EAAS,OAAO+D,QAAQ/D,GAAf;AACT,aAAO,KAAP;AACD;;AAED;;;;;;;;;4CAMwBuD,I,EAAMrD,Y,EAAc;AAC1C,UAAIgD,MAAM,CAAV;AACA,WAAK,IAAIc,IAAI,CAAb,EAAgBA,IAAIT,KAAK5B,MAAzB,EAAiC,EAAEqC,CAAnC,EAAsC;AACpCd,eAAO,KAAKe,YAAL,CAAkBV,KAAKS,CAAL,EAAQrB,KAA1B,EAAiCY,KAAKS,CAAL,EAAQjB,MAAzC,EAAiD7C,YAAjD,CAAP;AACD;AACD,aAAOgD,MAAMK,KAAK5B,MAAlB;AACD;;AAED;;;;;;;;uCAKmB4B,I,EAAMW,M,EAAQzD,O,EAAS;AACxCyD,aAAOpE,UAAP;AACAoE,aAAOC,KAAP,GAAe,KAAKC,uBAAL,CAA6Bb,IAA7B,EAAmC9C,QAAQP,YAA3C,CAAf;;AAEA,UAAIO,QAAQT,GAAR,IAAgBkE,OAAOpE,UAAP,GAAoBW,QAAQR,SAA5B,KAA0C,CAA9D,EAAkE;AAChEQ,gBAAQT,GAAR,kBAA2BkE,OAAOpE,UAAlC,0BAAiEoE,OAAOC,KAAxE;AACD;;AAED,UAAI1D,QAAQN,QAAR,IAAqB+D,OAAOpE,UAAP,GAAoBW,QAAQL,cAA5B,KAA+C,CAAxE,EAA4E;AAC1EK,gBAAQN,QAAR,CAAiBO,OAAOC,MAAP,CAAcuD,MAAd,CAAjB;AACD;AACF;;AAED;;;;;;;;;0BAMMX,I,EAAqB;AAAA,UAAfc,QAAe,uEAAJ,EAAI;;AACzB,UAAM5D,UAAUC,OAAOC,MAAP,CAAc,EAAd,EAAkB,KAAKC,WAAL,CAAiB0D,aAAnC,EAAkDD,QAAlD,CAAhB;AACAd,aAAO,KAAKgB,UAAL,CAAgBhB,IAAhB,CAAP;AACA9C,cAAQT,GAAR,GAAc,KAAKwE,aAAL,CAAmB/D,QAAQT,GAA3B,CAAd;AACAS,cAAQP,YAAR,GAAuBmE,SAASnE,YAAT,IAAyB,KAAKA,YAA9B,IAA8CO,QAAQP,YAA7E;AACA,UAAIgE,SAAS;AACXC,eAAO,CADI;AAEXrE,oBAAY;AAFD,OAAb;;AAKA,UAAI,KAAKiB,KAAL,KAAe,IAAnB,EAAyB;AACvB,YAAIA,QAAQ,KAAK0D,iBAAL,CAAuBlB,IAAvB,CAAZ;AACA,aAAKmB,UAAL,CAAgB3D,KAAhB;AACD;;AAED,aAAQmD,OAAOpE,UAAP,GAAoBW,QAAQX,UAA5B,IAA0CoE,OAAOC,KAAP,GAAe1D,QAAQV,WAAzE,EAAsF;AACpF,aAAK4E,kBAAL,CAAwBpB,IAAxB,EAA8BW,MAA9B,EAAsCzD,OAAtC;AACD;;AAED,aAAOyD,MAAP;AACD;;AAED;;;;;;;;;;+BAOWX,I,EAAqB;AAAA;;AAAA,UAAfc,QAAe,uEAAJ,EAAI;;AAC9B,aAAO,IAAIO,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;AACtC,YAAMrE,UAAUC,OAAOC,MAAP,CAAc,EAAd,EAAkB,MAAKC,WAAL,CAAiB0D,aAAnC,EAAkDD,QAAlD,CAAhB;AACAd,eAAO,MAAKgB,UAAL,CAAgBhB,IAAhB,CAAP;AACA9C,gBAAQT,GAAR,GAAc,MAAKwE,aAAL,CAAmB/D,QAAQT,GAA3B,CAAd;AACAS,gBAAQP,YAAR,GAAuBmE,SAASnE,YAAT,IAAyB,MAAKA,YAA9B,IAA8CO,QAAQP,YAA7E;AACA,YAAI6E,UAAUC,KAAKC,GAAL,KAAaxE,QAAQyE,WAAnC;;AAEA,YAAIhB,SAAS;AACXC,iBAAO,CADI;AAEXrE,sBAAY;AAFD,SAAb;;AAKA,YAAI,MAAKiB,KAAL,KAAe,IAAnB,EAAyB;AACvB,cAAIA,QAAQ,MAAK0D,iBAAL,CAAuBlB,IAAvB,CAAZ;AACA,gBAAKmB,UAAL,CAAgB3D,KAAhB;AACD;;AAED,YAAMoE,QAAQ,IAAIrD,KAAJ,CAAUrB,QAAQX,UAAlB,CAAd;AACA,YAAMsF,OAAQ,mBAASD,KAAT,EAAgB;AAC5BE,iBAAO,IADqB;AAE5BC,gBAAM,gBAAM;AACV,kBAAKX,kBAAL,CAAwBpB,IAAxB,EAA8BW,MAA9B,EAAsCzD,OAAtC;;AAEA,gBAAIyD,OAAOC,KAAP,GAAe1D,QAAQV,WAA3B,EAAwC;AACtCqF,mBAAKG,IAAL;AACD;AACF,WAR2B;AAS5BC,gBAAM,gBAAM;AACVX,oBAAQX,MAAR;AACD;AAX2B,SAAhB,CAAd;;AAcAkB,aAAKK,IAAL;AACD,OAjCM,CAAP;AAkCD;;AAED;;;;;;;;;iCAMa9C,K,EAAO+C,M,EAAQxF,Y,EAAc;AACxCA,qBAAeA,gBAAgB,KAAKA,YAApC;;AAEA;AACA,WAAKuB,QAAL,CAAckB,KAAd;;AAEA;AACA,WAAKjB,eAAL,CAAqBgE,MAArB;AACA,WAAKC,aAAL,CAAmBzF,YAAnB;;AAEA,UAAIiE,QAAQ,mBAAI,KAAK7C,MAAL,CAAY,KAAKN,WAAjB,CAAJ,CAAZ;AACA,aAAOmD,KAAP;AACD;;AAED;;;;;;;2CAIuBuB,M,EAAQ;AAC7B,WAAK,IAAI9D,QAAQ,KAAKZ,WAAtB,EAAmCY,SAAS,CAA5C,EAA+CA,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIgB,SAAS,KAAK5B,OAAL,CAAaS,KAAb,EAAoBG,IAApB,CAAb;;AAEA,cAAIoC,QAAQ,CAAZ;AACA,cAAIvC,UAAU,KAAKZ,WAAnB,EAAgC;AAC9BmD,oBAAQuB,OAAO3D,IAAP,IAAegB,MAAvB;AACD,WAFD,MAGK;AACH,gBAAI3B,SAAS,KAAKA,MAAL,CAAYQ,QAAQ,CAApB,CAAb;AACA,iBAAK,IAAIuB,IAAI,CAAb,EAAgBA,IAAI/B,OAAOO,MAA3B,EAAmCwB,GAAnC,EAAwC;AACtCgB,uBAAS/C,OAAO+B,CAAP,IAAY,KAAKjC,OAAL,CAAaU,QAAQ,CAArB,EAAwBuB,CAAxB,EAA2BpB,IAA3B,CAArB;AACD;AACF;AACD,eAAKT,MAAL,CAAYM,KAAZ,EAAmBG,IAAnB,IAA2BoC,KAA3B;AACA,eAAK/C,MAAL,CAAYQ,KAAZ,EAAmBG,IAAnB,IAA2BoC,QAAQpB,MAAR,IAAkB,IAAIA,MAAtB,CAA3B;AACD;AACF;AACF;;AAED;;;;;;;wCAIoB2C,M,EAAQ;AAC1B,WAAK,IAAI9D,QAAQ,KAAKZ,WAAtB,EAAmCY,SAAS,CAA5C,EAA+CA,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIgB,SAAS,KAAK5B,OAAL,CAAaS,KAAb,EAAoBG,IAApB,CAAb;;AAEA,cAAIoC,QAAQ,CAAZ;AACA,cAAIvC,UAAU,KAAKZ,WAAnB,EAAgC;AAC9BmD,oBAAQuB,OAAO3D,IAAP,IAAegB,MAAvB;AACD,WAFD,MAGK;AACH,gBAAI3B,SAAS,KAAKA,MAAL,CAAYQ,QAAQ,CAApB,CAAb;AACA,iBAAK,IAAIuB,IAAI,CAAb,EAAgBA,IAAI/B,OAAOO,MAA3B,EAAmCwB,GAAnC,EAAwC;AACtCgB,uBAAS/C,OAAO+B,CAAP,IAAY,KAAKjC,OAAL,CAAaU,QAAQ,CAArB,EAAwBuB,CAAxB,EAA2BpB,IAA3B,CAArB;AACD;AACF;AACD,eAAKT,MAAL,CAAYM,KAAZ,EAAmBG,IAAnB,IAA2BoC,KAA3B;AACA,eAAK/C,MAAL,CAAYQ,KAAZ,EAAmBG,IAAnB,IAA2BgB,SAAS,CAAT,GAAaoB,KAAb,GAAqB,CAAhD;AACD;AACF;AACF;;AAED;;;;;;;6CAIyBuB,M,EAAQ;AAC/B,WAAK,IAAI9D,QAAQ,KAAKZ,WAAtB,EAAmCY,SAAS,CAA5C,EAA+CA,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIgB,SAAS,KAAK5B,OAAL,CAAaS,KAAb,EAAoBG,IAApB,CAAb;;AAEA,cAAIoC,QAAQ,CAAZ;AACA,cAAIvC,UAAU,KAAKZ,WAAnB,EAAgC;AAC9BmD,oBAAQuB,OAAO3D,IAAP,IAAegB,MAAvB;AACD,WAFD,MAGK;AACH,gBAAI3B,SAAS,KAAKA,MAAL,CAAYQ,QAAQ,CAApB,CAAb;AACA,iBAAK,IAAIuB,IAAI,CAAb,EAAgBA,IAAI/B,OAAOO,MAA3B,EAAmCwB,GAAnC,EAAwC;AACtCgB,uBAAS/C,OAAO+B,CAAP,IAAY,KAAKjC,OAAL,CAAaU,QAAQ,CAArB,EAAwBuB,CAAxB,EAA2BpB,IAA3B,CAArB;AACD;AACF;AACD,eAAKT,MAAL,CAAYM,KAAZ,EAAmBG,IAAnB,IAA2BoC,KAA3B;AACA,eAAK/C,MAAL,CAAYQ,KAAZ,EAAmBG,IAAnB,IAA2BgB,SAAS,CAAT,GAAaoB,KAAb,GAAqB,OAAOA,KAAvD;AACD;AACF;AACF;;AAED;;;;;;;wCAIoBuB,M,EAAQ;AAC1B,WAAK,IAAI9D,QAAQ,KAAKZ,WAAtB,EAAmCY,SAAS,CAA5C,EAA+CA,OAA/C,EAAwD;AACtD,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAIgB,SAAS,KAAK5B,OAAL,CAAaS,KAAb,EAAoBG,IAApB,CAAb;;AAEA,cAAIoC,QAAQ,CAAZ;AACA,cAAIvC,UAAU,KAAKZ,WAAnB,EAAgC;AAC9BmD,oBAAQuB,OAAO3D,IAAP,IAAegB,MAAvB;AACD,WAFD,MAGK;AACH,gBAAI3B,SAAS,KAAKA,MAAL,CAAYQ,QAAQ,CAApB,CAAb;AACA,iBAAK,IAAIuB,IAAI,CAAb,EAAgBA,IAAI/B,OAAOO,MAA3B,EAAmCwB,GAAnC,EAAwC;AACtCgB,uBAAS/C,OAAO+B,CAAP,IAAY,KAAKjC,OAAL,CAAaU,QAAQ,CAArB,EAAwBuB,CAAxB,EAA2BpB,IAA3B,CAArB;AACD;AACF;AACD,eAAKT,MAAL,CAAYM,KAAZ,EAAmBG,IAAnB,IAA2BoC,KAA3B;AACA,eAAK/C,MAAL,CAAYQ,KAAZ,EAAmBG,IAAnB,IAA2B,CAAC,IAAIgB,SAASA,MAAd,IAAwBoB,KAAnD;AACD;AACF;AACF;;AAED;;;;;;;kCAIcjE,Y,EAAc;AAC1B,WAAK,IAAI0B,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD,YAAIgE,WAAW,KAAKzE,OAAL,CAAaS,QAAQ,CAArB,CAAf;;AAEA,aAAK,IAAIG,OAAO,CAAhB,EAAmBA,OAAO,KAAKhB,KAAL,CAAWa,KAAX,CAA1B,EAA6CG,MAA7C,EAAqD;AACnD,cAAI8D,QAAQ,KAAKzE,MAAL,CAAYQ,KAAZ,EAAmBG,IAAnB,CAAZ;;AAEA,eAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIyC,SAASjE,MAA7B,EAAqCwB,GAArC,EAA0C;AACxC,gBAAI2C,SAAS,KAAKzE,OAAL,CAAaO,KAAb,EAAoBG,IAApB,EAA0BoB,CAA1B,CAAb;;AAEA2C,qBAAU5F,eAAe2F,KAAf,GAAuBD,SAASzC,CAAT,CAAxB,GACJ,KAAK9C,QAAL,GAAgByF,MADrB;;AAGA,iBAAKzE,OAAL,CAAaO,KAAb,EAAoBG,IAApB,EAA0BoB,CAA1B,IAA+B2C,MAA/B;AACA,iBAAK5E,OAAL,CAAaU,KAAb,EAAoBG,IAApB,EAA0BoB,CAA1B,KAAgC2C,MAAhC;AACD;AACD,eAAK7E,MAAL,CAAYW,KAAZ,EAAmBG,IAAnB,KAA4B7B,eAAe2F,KAA3C;AACD;AACF;AACF;;AAED;;;;;;;;+BAKWtC,I,EAAM;AAAA;;AACf,UAAI,CAACzB,MAAMiE,OAAN,CAAcxC,IAAd,CAAL,EAA0B;AAAE;AAC1B,YAAIyC,MAAM,EAAV;AACAA,YAAItC,IAAJ,CAASH,IAAT;AACAA,eAAOyC,GAAP;AACD;AACD;AACA,UAAIC,QAAQ1C,KAAK,CAAL,EAAQZ,KAApB;AACA,UAAI,CAACb,MAAMiE,OAAN,CAAcE,KAAd,CAAD,IAAyB,EAAEA,iBAAiBC,YAAnB,CAA7B,EAA+D;AAC7D,YAAI,CAAC,KAAKrD,WAAV,EAAuB;AACrB,eAAKA,WAAL,GAAmB,iBAAOsD,WAAP,CAAmB5C,KAAK6C,GAAL,CAAS;AAAA,mBAASC,MAAM,OAAN,CAAT;AAAA,WAAT,CAAnB,CAAnB;AACD;AACD9C,eAAOA,KAAK6C,GAAL,CAAS,iBAAS;AACvB,cAAIE,QAAQ,iBAAOxD,OAAP,CAAe,OAAKD,WAApB,EAAiCoD,MAAMtD,KAAvC,CAAZ;AACA,iBAAOjC,OAAOC,MAAP,CAAc,EAAd,EAAkBsF,KAAlB,EAAyB,EAAEtD,OAAO2D,KAAT,EAAzB,CAAP;AACD,SAHM,EAGJ,IAHI,CAAP;AAID;;AAED,UAAI,CAACxE,MAAMiE,OAAN,CAAcxC,KAAK,CAAL,EAAQR,MAAtB,CAAL,EAAoC;AAClC,YAAI,CAAC,KAAKC,YAAV,EAAwB;AACtB,eAAKA,YAAL,GAAoB,iBAAOmD,WAAP,CAAmB5C,KAAK6C,GAAL,CAAS;AAAA,mBAASC,MAAM,QAAN,CAAT;AAAA,WAAT,CAAnB,CAApB;AACD;AACD9C,eAAOA,KAAK6C,GAAL,CAAS,iBAAS;AACvB,cAAIE,QAAQ,iBAAOxD,OAAP,CAAe,OAAKE,YAApB,EAAkCiD,MAAMlD,MAAxC,CAAZ;AACA,iBAAOrC,OAAOC,MAAP,CAAc,EAAd,EAAkBsF,KAAlB,EAAyB,EAAElD,QAAQuD,KAAV,EAAzB,CAAP;AACD,SAHM,EAGJ,IAHI,CAAP;AAID;AACD,aAAO/C,IAAP;AACD;;AAED;;;;;;;;;;;;;yBAUKA,I,EAAM;AAAA;;AACTA,aAAO,KAAKgB,UAAL,CAAgBhB,IAAhB,CAAP;;AAEA;AACA,UAAIgD,WAAWhD,KAAK,CAAL,EAAQR,MAAR,CAAepB,MAAf,KAA0B,CAAzC;AACA,UAAI6E,WAAW,CAAf;AACA,UAAIC,WAAW,CAAf;AACA,UAAIC,UAAU,CAAd;AACA,UAAIC,UAAU,CAAd;;AAEA;AACA,UAAIC,aAAa,EAAjB;;AAEA;AACA;AACA,UAAI1D,MAAM,CAAV;;AAfS,iCAgBAc,CAhBA;AAiBP,YAAIjB,SAAS,OAAKtB,QAAL,CAAc8B,KAAKS,CAAL,EAAQrB,KAAtB,CAAb;AACA,YAAI+C,SAASnC,KAAKS,CAAL,EAAQjB,MAArB;;AAEA,YAAI8D,eAAJ;AAAA,YAAYC,iBAAZ;AACA,YAAIP,QAAJ,EAAc;AACZM,mBAAS9D,OAAO,CAAP,IAAY,OAAKzC,YAAjB,GAAgC,CAAhC,GAAoC,CAA7C;AACAwG,qBAAWpB,OAAO,CAAP,CAAX;AACD,SAHD,MAIK;AACHmB,mBAAS9D,OAAOgE,OAAP,CAAe,mBAAIhE,MAAJ,CAAf,CAAT;AACA+D,qBAAWpB,OAAOqB,OAAP,CAAe,mBAAIrB,MAAJ,CAAf,CAAX;AACD;;AAED,YAAImB,WAAWC,QAAf,EAAyB;AACvB,cAAIE,WAAWzD,KAAKS,CAAL,CAAf;AACAtD,iBAAOC,MAAP,CAAcqG,QAAd,EAAwB;AACtBH,oBAAQA,MADc;AAEtBC,sBAAUA;AAFY,WAAxB;AAIAF,qBAAWlD,IAAX,CAAgBsD,QAAhB;AACD;;AAED,YAAIT,QAAJ,EAAc;AACZ,cAAIM,WAAW,CAAX,IAAgBC,aAAa,CAAjC,EAAoC;AAClCH;AACD,WAFD,MAEO,IAAIE,WAAW,CAAX,IAAgBC,aAAa,CAAjC,EAAoC;AACzCJ;AACD,WAFM,MAEA,IAAIG,WAAW,CAAX,IAAgBC,aAAa,CAAjC,EAAoC;AACzCL;AACD,WAFM,MAEA,IAAII,WAAW,CAAX,IAAgBC,aAAa,CAAjC,EAAoC;AACzCN;AACD;AACF;;AAED,YAAIlF,SAASyB,OAAOqD,GAAP,CAAW,UAACC,KAAD,EAAQrC,CAAR,EAAc;AACpC,iBAAO0B,OAAO1B,CAAP,IAAYqC,KAAnB;AACD,SAFY,CAAb;AAGAnD,eAAO,mBAAI5B,MAAJ,CAAP;AAtDO;;AAgBT,WAAK,IAAI0C,IAAI,CAAb,EAAgBA,IAAIT,KAAK5B,MAAzB,EAAiCqC,GAAjC,EAAsC;AAAA,cAA7BA,CAA6B;AAuCrC;AACD,UAAIG,QAAQjB,MAAMK,KAAK5B,MAAvB;;AAEA,UAAIsF,QAAQ;AACV9C,eAAOA,KADG;AAEVyC,oBAAYA;AAFF,OAAZ;;AAKA,UAAIL,QAAJ,EAAc;AACZ7F,eAAOC,MAAP,CAAcsG,KAAd,EAAqB;AACnBN,mBAASA,OADU;AAEnBD,mBAASA,OAFU;AAGnBD,oBAAUA,QAHS;AAInBD,oBAAUA,QAJS;AAKnBU,iBAAO3D,KAAK5B,MALO;AAMnBwF,qBAAWT,WAAWA,UAAUF,QAArB,CANQ;AAOnBY,kBAAQV,WAAWA,UAAUD,QAArB,CAPW;AAQnBY,oBAAU,CAACV,UAAUD,OAAX,IAAsBnD,KAAK5B;AARlB,SAArB;AAUD;AACD,aAAOsF,KAAP;AACD;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAoCS;AACP,UAAIK,SAAS,EAAb;AACA,WAAK,IAAI1F,QAAQ,CAAjB,EAAoBA,SAAS,KAAKZ,WAAlC,EAA+CY,OAA/C,EAAwD;AACtD0F,eAAO1F,KAAP,IAAgB,EAAhB;;AAEA,YAAI2F,cAAJ;AACA;AACA,YAAI3F,UAAU,CAAV,IAAe,KAAKiB,WAAxB,EAAqC;AACnC0E,kBAAQ7G,OAAO8G,IAAP,CAAY,KAAK3E,WAAjB,CAAR;AACD,SAFD,MAGK,IAAIjB,UAAU,KAAKZ,WAAf,IAA8B,KAAKgC,YAAvC,EAAqD;AACxDuE,kBAAQ7G,OAAO8G,IAAP,CAAY,KAAKxE,YAAjB,CAAR;AACD,SAFI,MAGA;AACHuE,kBAAQ,qBAAM,CAAN,EAAS,KAAKxG,KAAL,CAAWa,KAAX,CAAT,CAAR;AACD;;AAED,aAAK,IAAI6F,IAAI,CAAb,EAAgBA,IAAIF,MAAM5F,MAA1B,EAAkC8F,GAAlC,EAAuC;AACrC,cAAI1F,OAAOwF,MAAME,CAAN,CAAX;AACAH,iBAAO1F,KAAP,EAAcG,IAAd,IAAsB,EAAtB;;AAEA,cAAIH,QAAQ,CAAZ,EAAe;AACb0F,mBAAO1F,KAAP,EAAcG,IAAd,EAAoB2F,IAApB,GAA2B,KAAKzG,MAAL,CAAYW,KAAZ,EAAmB6F,CAAnB,CAA3B;AACAH,mBAAO1F,KAAP,EAAcG,IAAd,EAAoBb,OAApB,GAA8B,EAA9B;AACA,iBAAK,IAAIiC,CAAT,IAAcmE,OAAO1F,QAAQ,CAAf,CAAd,EAAiC;AAC/B,kBAAI+F,QAAQxE,CAAZ;AACA,kBAAIvB,UAAU,CAAV,IAAe,KAAKiB,WAAxB,EAAqC;AACnC8E,wBAAQ,KAAK9E,WAAL,CAAiBM,CAAjB,CAAR;AACD;AACDmE,qBAAO1F,KAAP,EAAcG,IAAd,EAAoBb,OAApB,CAA4BiC,CAA5B,IAAiC,KAAKjC,OAAL,CAAaU,KAAb,EAAoB6F,CAApB,EAAuBE,KAAvB,CAAjC;AACD;AACF;AACF;AACF;AACD,aAAO;AACL5G,eAAO,KAAKA,KADP;AAELuG,sBAFK;AAGLtE,sBAAa,CAAC,CAAC,KAAKA,YAHf;AAILH,qBAAY,CAAC,CAAC,KAAKA,WAJd;AAKLrC,oBAAY,KAAKA;AALZ,OAAP;AAOD;;AAED;;;;;;;;6BAKUoH,I,EAAM;AACd,WAAKlD,UAAL,CAAiBkD,KAAK7G,KAAtB;;AAEA,WAAK,IAAIiD,IAAI,CAAb,EAAgBA,KAAK,KAAKhD,WAA1B,EAAuCgD,GAAvC,EAA4C;AAC1C,YAAIpC,QAAQgG,KAAKN,MAAL,CAAYtD,CAAZ,CAAZ;AACA,YAAIA,MAAM,CAAN,KAAY,CAACpC,MAAM,CAAN,CAAD,IAAagG,KAAK/E,WAA9B,CAAJ,EAAgD;AAC9C,eAAKA,WAAL,GAAmB,iBAAOgF,cAAP,CAAsBjG,KAAtB,CAAnB;AACD,SAFD,MAGK,IAAIoC,MAAM,KAAKhD,WAAX,KAA2B,CAACY,MAAM,CAAN,CAAD,IAAagG,KAAK5E,YAA7C,CAAJ,EAAgE;AACnE,eAAKA,YAAL,GAAoB,iBAAO6E,cAAP,CAAsBjG,KAAtB,CAApB;AACD;AACD,YAAIoC,IAAI,CAAR,EAAW;AACT,cAAMuD,QAAQ7G,OAAO8G,IAAP,CAAY5F,KAAZ,CAAd;AACA,eAAKb,KAAL,CAAWiD,CAAX,IAAgBuD,MAAM5F,MAAtB;AACA,eAAK,IAAI8F,CAAT,IAAcF,KAAd,EAAqB;AACnB,gBAAMxF,OAAOwF,MAAME,CAAN,CAAb;AACA,iBAAKxG,MAAL,CAAY+C,CAAZ,EAAeyD,CAAf,IAAoB7F,MAAMG,IAAN,EAAY2F,IAAhC;AACA,iBAAKxG,OAAL,CAAa8C,CAAb,EAAgByD,CAAhB,IAAqB,uBAAQ7F,MAAMG,IAAN,EAAYb,OAApB,CAArB;AACD;AACF;AACF;;AAED,WAAKe,aAAL;AACA,aAAO,IAAP;AACD;;AAED;;;;;;;iCAIa;AACX,UAAMzB,aAAa,KAAKA,UAAxB;AACA,eAASsH,UAAT,CAAoBR,MAApB,EAA4BS,WAA5B,EAAyCC,OAAzC,EAAkD;AAChD,YAAID,gBAAgB,CAApB,EAAuB;AACrB,iBAAQ,OAAOC,OAAP,KAAmB,QAAnB,gBACMA,OADN,sBAEKA,OAFL,MAAR;AAGD;;AAED,YAAMpG,QAAQ0F,OAAOS,WAAP,CAAd;AACA,YAAMhG,OAAOH,MAAMoG,OAAN,CAAb;AACA,YAAIC,SAAS,CAAClG,KAAK2F,IAAN,CAAb;AACA,aAAK,IAAIQ,CAAT,IAAcnG,KAAKb,OAAnB,EAA4B;AAC1B,cAAIa,KAAKb,OAAL,CAAagH,CAAb,IAAkB,CAAtB,EAAyB;AACvBD,mBAAOvE,IAAP,CAAe3B,KAAKb,OAAL,CAAagH,CAAb,CAAf,UAAmCJ,WAAWR,MAAX,EAAmBS,cAAc,CAAjC,EAAoCG,CAApC,CAAnC;AACD,WAFD,MAEO;AACLD,mBAAOvE,IAAP,OAAgB3B,KAAKb,OAAL,CAAagH,CAAb,CAAhB,UAAoCJ,WAAWR,MAAX,EAAmBS,cAAc,CAAjC,EAAoCG,CAApC,CAApC;AACD;AACF;;AAED,gBAAQ1H,UAAR;AACE,eAAK,SAAL;AACE,wCAA0ByH,OAAOE,IAAP,CAAY,EAAZ,CAA1B;AACF,eAAK,MAAL;AACE,kCAAoBF,OAAOE,IAAP,CAAY,EAAZ,CAApB;AACF,eAAK,YAAL;AACE,kCAAoBF,OAAOE,IAAP,CAAY,EAAZ,CAApB;AACF,eAAK,MAAL;AACE,kCAAoBF,OAAOE,IAAP,CAAY,EAAZ,CAApB;AACF;AACE,kBAAM,IAAIzF,KAAJ,CAAU,6BAA6BlC,UAAvC,CAAN;AAVJ;AAYD;;AAED,UAAM8G,SAAS,KAAKc,MAAL,GAAcd,MAA7B;AACA,UAAMe,eAAe,EAArB;AACA,UAAIJ,eAAJ;AACA,WAAK,IAAIjE,CAAT,IAAcsD,OAAOA,OAAO3F,MAAP,GAAgB,CAAvB,CAAd,EAAyC;AACvC0G,qBAAa3E,IAAb,CAAkBoE,WAAWR,MAAX,EAAmBA,OAAO3F,MAAP,GAAgB,CAAnC,EAAsCqC,CAAtC,CAAlB;AACD;AACD,UAAI,KAAKhB,YAAT,EAAuB;AACrBiF,uBACEvH,OAAO8G,IAAP,CAAY,KAAKxE,YAAjB,EACGoD,GADH,CACO,UAACkC,GAAD,EAAMtE,CAAN;AAAA,wBAAgBsE,GAAhB,WAAwBD,aAAarE,CAAb,CAAxB;AAAA,SADP,CADF;AAID,OALD,MAKO;AACLiE,uBAAaI,aAAaF,IAAb,CAAkB,GAAlB,CAAb;AACD;AACD,aAAO,IAAII,QAAJ,CAAa,OAAb,cAAgCN,MAAhC,CAAP;AACD;;AAED;;;;;;;;sCAKkBO,I,EAAM;AACtBA,aAAOA,QAAQ,EAAf;AACAA,WAAKC,aAAL,GAAqB,IAArB;AACA,WAAKxG,aAAL;AACA,WAAKyG,WAAL,GAAmB,0BAAgBF,IAAhB,CAAnB;AACA,aAAO,KAAKE,WAAZ;AACD;;;wBAzsBe;AAAA;;AACd,UAAG,CAAC,KAAKjH,QAAT,EAAkB;AAChBsC,gBAAQI,KAAR,CAAc,oEAAd;AACA,eAAO,KAAP;AACD;;AAED,UAAMwE,WAAW,CACf,OADe,EAEf,aAFe,EAGf,QAHe,EAIf,SAJe,EAKf,SALe,EAMf,QANe,EAOf,SAPe,EAQf,QARe,EASfC,MATe,CASR;AAAA,eAAK,OAAKC,CAAL,MAAY,IAAjB;AAAA,OATQ,CAAjB;;AAWA,UAAGF,SAAShH,MAAT,GAAkB,CAArB,EAAuB;AACrBoC,gBAAQI,KAAR,iGAA4GwE,SAASR,IAAT,CAAc,IAAd,CAA5G;AACA,eAAO,KAAP;AACD;AACD,aAAO,IAAP;AACD;;;;;;kBArIkBtI,a","file":"neural-network.js","sourcesContent":["import lookup from './lookup';\nimport TrainStream from './train-stream';\nimport max from './utilities/max';\nimport mse from './utilities/mse';\nimport randos from './utilities/randos';\nimport range from './utilities/range';\nimport toArray from './utilities/to-array';\nimport zeros from './utilities/zeros';\nimport Thaw from 'thaw.js';\n\n/**\n * @param {object} options\n * @constructor\n */\nexport default class NeuralNetwork {\n  static get trainDefaults() {\n    return {\n      iterations: 20000,\n      errorThresh: 0.005,\n      log: false,\n      logPeriod: 10,\n      learningRate: 0.3,\n      callback: null,\n      callbackPeriod: 10\n    };\n  }\n\n  static get defaults() {\n    return {\n      learningRate: 0.3,\n      momentum: 0.1,\n      binaryThresh: 0.5,\n      hiddenLayers: null,\n      activation: 'sigmoid'\n    };\n  }\n\n  constructor(options = {}) {\n    Object.assign(this, this.constructor.defaults, options);\n    this.hiddenSizes = options.hiddenLayers;\n\n    this.sizes = null;\n    this.outputLayer = null;\n    this.biases = null; // weights for bias nodes\n    this.weights = null;\n    this.outputs = null;\n\n    // state for training\n    this.deltas = null;\n    this.changes = null; // for momentum\n    this.errors = null;\n\n    if (!this.constructor.prototype.hasOwnProperty('runInput')) {\n      this.runInput = null;\n    }\n    if (!this.constructor.prototype.hasOwnProperty('calculateDeltas')) {\n      this.calculateDeltas = null;\n    }\n  }\n\n  /**\n   *\n   * @param {Number[]} sizes\n   */\n  initialize(sizes) {\n    this.sizes = sizes;\n    this.outputLayer = this.sizes.length - 1;\n    this.biases = []; // weights for bias nodes\n    this.weights = [];\n    this.outputs = [];\n\n    // state for training\n    this.deltas = [];\n    this.changes = []; // for momentum\n    this.errors = [];\n\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      let size = this.sizes[layer];\n      this.deltas[layer] = zeros(size);\n      this.errors[layer] = zeros(size);\n      this.outputs[layer] = zeros(size);\n\n      if (layer > 0) {\n        this.biases[layer] = randos(size);\n        this.weights[layer] = new Array(size);\n        this.changes[layer] = new Array(size);\n\n        for (let node = 0; node < size; node++) {\n          let prevSize = this.sizes[layer - 1];\n          this.weights[layer][node] = randos(prevSize);\n          this.changes[layer][node] = zeros(prevSize);\n        }\n      }\n    }\n\n    this.setActivation();\n  }\n\n  setActivation() {\n    switch (this.activation) {\n      case 'sigmoid':\n        this.runInput = this.runInput || this.runInputSigmoid;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;\n        break;\n      case 'relu':\n        this.runInput = this.runInput || this.runInputRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;\n        break;\n      case 'leaky-relu':\n        this.runInput = this.runInput || this.runInputLeakyRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;\n        break;\n      case 'tanh':\n        this.runInput = this.runInput || this.runInputTanh;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;\n        break;\n      default:\n        throw new Error('unknown activation ' + this.activation);\n    }\n  }\n\n  /**\n   *\n   * @returns boolean\n   */\n  get isRunnable(){\n    if(!this.runInput){\n      console.error('Activation function has not been initialized, did you run train()?');\n      return false;\n    }\n\n    const checkFns = [\n      'sizes',\n      'outputLayer',\n      'biases',\n      'weights',\n      'outputs',\n      'deltas',\n      'changes',\n      'errors',\n    ].filter(c => this[c] === null);\n\n    if(checkFns.length > 0){\n      console.error(`Some settings have not been initialized correctly, did you run train()? Found issues with: ${checkFns.join(', ')}`);\n      return false;\n    }\n    return true;\n  }\n\n\n  /**\n   *\n   * @param input\n   * @returns {*}\n   */\n  run(input) {\n    if (!this.isRunnable) return null;\n    if (this.inputLookup) {\n      input = lookup.toArray(this.inputLookup, input);\n    }\n\n    let output = [...this.runInput(input)];\n\n    if (this.outputLookup) {\n      output = lookup.toHash(this.outputLookup, output);\n    }\n    return output;\n  }\n\n  /**\n   * trains via sigmoid\n   * @param input\n   * @returns {*}\n   */\n  runInputSigmoid(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //sigmoid\n        this.outputs[layer][node] = 1 / (1 + Math.exp(-sum));\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputLeakyRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //leaky relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : 0.01 * sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputTanh(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //tanh\n        this.outputs[layer][node] = Math.tanh(sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  /**\n   *\n   * @param data\n   * @returns sizes\n   */\n  _getSizesFromData(data) {\n    let sizes = [];\n    let inputSize = data[0].input.length;\n    let outputSize = data[0].output.length;\n    let hiddenSizes = this.hiddenSizes;\n    if (!hiddenSizes) {\n      sizes.push(Math.max(3, Math.floor(inputSize / 2)));\n    } else {\n      hiddenSizes.forEach(size => {\n        sizes.push(size);\n      });\n    }\n\n    sizes.unshift(inputSize);\n    sizes.push(outputSize);\n    return sizes;\n  }\n\n\n  /**\n   *\n   * @param log\n   * if a method is passed in method is used\n   * if false passed in nothing is logged\n   * @returns error\n   */\n  _setLogMethod(log) {\n    if (log) return console.log;\n    return false;\n  }\n\n  /**\n   *\n   * @param data\n   * @param learning Rate\n   * @returns error\n   */\n  _calculateTrainingError(data, learningRate) {\n    let sum = 0;\n    for (let i = 0; i < data.length; ++i) {\n      sum += this.trainPattern(data[i].input, data[i].output, learningRate);\n    }\n    return sum / data.length;\n  }\n\n  /**\n   *\n   * @param status { iterations: number, error: number}\n   * @param options\n   */\n  _checkTrainingTick(data, status, options) {\n    status.iterations++;\n    status.error = this._calculateTrainingError(data, options.learningRate);\n\n    if (options.log && (status.iterations % options.logPeriod === 0)) {\n      options.log(`iterations: ${status.iterations}, training error: ${status.error}`);\n    }\n\n    if (options.callback && (status.iterations % options.callbackPeriod === 0)) {\n      options.callback(Object.assign(status));\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param _options\n   * @returns {{error: number, iterations: number}}\n   */\n  train(data, _options = {}) {\n    const options = Object.assign({}, this.constructor.trainDefaults, _options);\n    data = this.formatData(data);\n    options.log = this._setLogMethod(options.log);\n    options.learningRate = _options.learningRate || this.learningRate || options.learningRate;\n    var status = {\n      error: 1,\n      iterations: 0\n    };\n\n    if (this.sizes === null) {\n      let sizes = this._getSizesFromData(data);\n      this.initialize(sizes);\n    }\n\n    while ( status.iterations < options.iterations && status.error > options.errorThresh) {\n      this._checkTrainingTick(data, status, options);\n    }\n\n    return status;\n  }\n\n  /**\n   *\n   * @param data\n   * @param _options\n   * @param cb\n   * @returns {{error: number, iterations: number}}\n   */\n  trainAsync(data, _options = {}) {\n    return new Promise((resolve, reject) => {\n      const options = Object.assign({}, this.constructor.trainDefaults, _options);\n      data = this.formatData(data);\n      options.log = this._setLogMethod(options.log);\n      options.learningRate = _options.learningRate || this.learningRate || options.learningRate;\n      let endTime = Date.now() + options.trainTimeMs;\n\n      let status = {\n        error: 1,\n        iterations: 0\n      };\n\n      if (this.sizes === null) {\n        let sizes = this._getSizesFromData(data);\n        this.initialize(sizes);\n      }\n\n      const items = new Array(options.iterations);\n      const thaw  = new Thaw(items, {\n        delay: true,\n        each: () => {\n          this._checkTrainingTick(data, status, options);\n\n          if (status.error < options.errorThresh) {\n            thaw.stop();\n          }\n        },\n        done: () => {\n          resolve(status);\n        }\n      });\n\n      thaw.tick();\n    });\n  }\n\n  /**\n   *\n   * @param input\n   * @param target\n   * @param learningRate\n   */\n  trainPattern(input, target, learningRate) {\n    learningRate = learningRate || this.learningRate;\n\n    // forward propagate\n    this.runInput(input);\n\n    // back propagate\n    this.calculateDeltas(target);\n    this.adjustWeights(learningRate);\n\n    let error = mse(this.errors[this.outputLayer]);\n    return error;\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasSigmoid(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = error * output * (1 - output);\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasLeakyRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0.01 * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasTanh(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = (1 - output * output) * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param learningRate\n   */\n  adjustWeights(learningRate) {\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      let incoming = this.outputs[layer - 1];\n\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let delta = this.deltas[layer][node];\n\n        for (let k = 0; k < incoming.length; k++) {\n          let change = this.changes[layer][node][k];\n\n          change = (learningRate * delta * incoming[k])\n            + (this.momentum * change);\n\n          this.changes[layer][node][k] = change;\n          this.weights[layer][node][k] += change;\n        }\n        this.biases[layer][node] += learningRate * delta;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {*}\n   */\n  formatData(data) {\n    if (!Array.isArray(data)) { // turn stream datum into array\n      let tmp = [];\n      tmp.push(data);\n      data = tmp;\n    }\n    // turn sparse hash input into arrays with 0s as filler\n    let datum = data[0].input;\n    if (!Array.isArray(datum) && !(datum instanceof Float32Array)) {\n      if (!this.inputLookup) {\n        this.inputLookup = lookup.buildLookup(data.map(value => value['input']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.inputLookup, datum.input);\n        return Object.assign({}, datum, { input: array });\n      }, this);\n    }\n\n    if (!Array.isArray(data[0].output)) {\n      if (!this.outputLookup) {\n        this.outputLookup = lookup.buildLookup(data.map(value => value['output']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.outputLookup, datum.output);\n        return Object.assign({}, datum, { output: array });\n      }, this);\n    }\n    return data;\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {\n   *  {\n   *    error: number,\n   *    misclasses: Array\n   *  }\n   * }\n   */\n  test(data) {\n    data = this.formatData(data);\n\n    // for binary classification problems with one output node\n    let isBinary = data[0].output.length === 1;\n    let falsePos = 0;\n    let falseNeg = 0;\n    let truePos = 0;\n    let trueNeg = 0;\n\n    // for classification problems\n    let misclasses = [];\n\n    // run each pattern through the trained network and collect\n    // error and misclassification statistics\n    let sum = 0;\n    for (let i = 0; i < data.length; i++) {\n      let output = this.runInput(data[i].input);\n      let target = data[i].output;\n\n      let actual, expected;\n      if (isBinary) {\n        actual = output[0] > this.binaryThresh ? 1 : 0;\n        expected = target[0];\n      }\n      else {\n        actual = output.indexOf(max(output));\n        expected = target.indexOf(max(target));\n      }\n\n      if (actual !== expected) {\n        let misclass = data[i];\n        Object.assign(misclass, {\n          actual: actual,\n          expected: expected\n        });\n        misclasses.push(misclass);\n      }\n\n      if (isBinary) {\n        if (actual === 0 && expected === 0) {\n          trueNeg++;\n        } else if (actual === 1 && expected === 1) {\n          truePos++;\n        } else if (actual === 0 && expected === 1) {\n          falseNeg++;\n        } else if (actual === 1 && expected === 0) {\n          falsePos++;\n        }\n      }\n\n      let errors = output.map((value, i) => {\n        return target[i] - value;\n      });\n      sum += mse(errors);\n    }\n    let error = sum / data.length;\n\n    let stats = {\n      error: error,\n      misclasses: misclasses\n    };\n\n    if (isBinary) {\n      Object.assign(stats, {\n        trueNeg: trueNeg,\n        truePos: truePos,\n        falseNeg: falseNeg,\n        falsePos: falsePos,\n        total: data.length,\n        precision: truePos / (truePos + falsePos),\n        recall: truePos / (truePos + falseNeg),\n        accuracy: (trueNeg + truePos) / data.length\n      });\n    }\n    return stats;\n  }\n\n  /**\n   *\n   * @returns\n   *  {\n   *    layers: [\n   *      {\n   *        x: {},\n   *        y: {}\n   *      },\n   *      {\n   *        '0': {\n   *          bias: -0.98771313,\n   *          weights: {\n   *            x: 0.8374838,\n   *            y: 1.245858\n   *          },\n   *        '1': {\n   *          bias: 3.48192004,\n   *          weights: {\n   *            x: 1.7825821,\n   *            y: -2.67899\n   *          }\n   *        }\n   *      },\n   *      {\n   *        f: {\n   *          bias: 0.27205739,\n   *          weights: {\n   *            '0': 1.3161821,\n   *            '1': 2.00436\n   *          }\n   *        }\n   *      }\n   *    ]\n   *  }\n   */\n  toJSON() {\n    let layers = [];\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      layers[layer] = {};\n\n      let nodes;\n      // turn any internal arrays back into hashes for readable json\n      if (layer === 0 && this.inputLookup) {\n        nodes = Object.keys(this.inputLookup);\n      }\n      else if (layer === this.outputLayer && this.outputLookup) {\n        nodes = Object.keys(this.outputLookup);\n      }\n      else {\n        nodes = range(0, this.sizes[layer]);\n      }\n\n      for (let j = 0; j < nodes.length; j++) {\n        let node = nodes[j];\n        layers[layer][node] = {};\n\n        if (layer > 0) {\n          layers[layer][node].bias = this.biases[layer][j];\n          layers[layer][node].weights = {};\n          for (let k in layers[layer - 1]) {\n            let index = k;\n            if (layer === 1 && this.inputLookup) {\n              index = this.inputLookup[k];\n            }\n            layers[layer][node].weights[k] = this.weights[layer][j][index];\n          }\n        }\n      }\n    }\n    return {\n      sizes: this.sizes,\n      layers,\n      outputLookup:!!this.outputLookup,\n      inputLookup:!!this.inputLookup,\n      activation: this.activation\n    };\n  }\n\n  /**\n   *\n   * @param json\n   * @returns {NeuralNetwork}\n   */\n  fromJSON (json) {\n    this.initialize (json.sizes);\n\n    for (let i = 0; i <= this.outputLayer; i++) {\n      let layer = json.layers[i];\n      if (i === 0 && (!layer[0] || json.inputLookup)) {\n        this.inputLookup = lookup.lookupFromHash(layer);\n      }\n      else if (i === this.outputLayer && (!layer[0] || json.outputLookup)) {\n        this.outputLookup = lookup.lookupFromHash(layer);\n      }\n      if (i > 0) {\n        const nodes = Object.keys(layer);\n        this.sizes[i] = nodes.length;\n        for (let j in nodes) {\n          const node = nodes[j];\n          this.biases[i][j] = layer[node].bias;\n          this.weights[i][j] = toArray(layer[node].weights);\n        }\n      }\n    }\n\n    this.setActivation();\n    return this;\n  }\n\n  /**\n   *\n   * @returns {Function}\n   */\n  toFunction() {\n    const activation = this.activation;\n    function nodeHandle(layers, layerNumber, nodeKey) {\n      if (layerNumber === 0) {\n        return (typeof nodeKey === 'string'\n          ? `input['${nodeKey}']`\n          : `input[${nodeKey}]`);\n      }\n\n      const layer = layers[layerNumber];\n      const node = layer[nodeKey];\n      let result = [node.bias];\n      for (let w in node.weights) {\n        if (node.weights[w] < 0) {\n          result.push(`${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        } else {\n          result.push(`+${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        }\n      }\n\n      switch (activation) {\n        case 'sigmoid':\n          return `1/(1+1/Math.exp(${result.join('')}))`;\n        case 'relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : sum);`;\n        case 'leaky-relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : 0.01 * sum);`;\n        case 'tanh':\n          return `Math.tanh(${result.join('')});`;\n        default:\n          throw new Error('unknown activation type ' + activation);\n      }\n    }\n\n    const layers = this.toJSON().layers;\n    const layersAsMath = [];\n    let result;\n    for (let i in layers[layers.length - 1]) {\n      layersAsMath.push(nodeHandle(layers, layers.length - 1, i));\n    }\n    if (this.outputLookup) {\n      result = `{${\n        Object.keys(this.outputLookup)\n          .map((key, i) => `'${key}':${layersAsMath[i]}`)\n      }}`;\n    } else {\n      result = `[${layersAsMath.join(',')}]`;\n    }\n    return new Function('input', `return ${result}`);\n  }\n\n  /**\n   * This will create a TrainStream (WriteStream) for us to send the training data to.\n   * @param opts training options\n   * @returns {TrainStream|*}\n   */\n  createTrainStream(opts) {\n    opts = opts || {};\n    opts.neuralNetwork = this;\n    this.setActivation();\n    this.trainStream = new TrainStream(opts);\n    return this.trainStream;\n  }\n}"]}
\ No newline at end of file
+{"version":3,"sources":["../src/neural-network.js"],"names":["NeuralNetwork","iterations","errorThresh","log","logPeriod","learningRate","momentum","callback","callbackPeriod","timeout","Infinity","binaryThresh","hiddenLayers","activation","options","Object","assign","constructor","defaults","hiddenSizes","trainOpts","updateTrainingOptions","trainDefaults","sizes","outputLayer","biases","weights","outputs","deltas","changes","errors","prototype","hasOwnProperty","runInput","calculateDeltas","Error","length","layer","size","Array","node","prevSize","setActivation","runInputSigmoid","calculateDeltasSigmoid","runInputRelu","calculateDeltasRelu","runInputLeakyRelu","calculateDeltasLeakyRelu","runInputTanh","calculateDeltasTanh","input","isRunnable","inputLookup","toArray","output","outputLookup","toHash","sum","k","Math","exp","tanh","data","push","max","floor","forEach","_initialize","opts","_setLogMethod","results","console","i","_trainPattern","status","error","_calculateTrainingError","formatData","endTime","Date","now","_verifyIsInitialized","_trainingTick","Promise","resolve","reject","items","thaw","delay","each","stop","done","tick","target","adjustWeights","incoming","delta","change","isArray","tmp","datum","Float32Array","buildLookup","map","value","array","isBinary","falsePos","falseNeg","truePos","trueNeg","misclasses","actual","expected","indexOf","misclass","stats","total","precision","recall","accuracy","layers","nodes","keys","j","bias","index","_getTrainOptsJSON","json","lookupFromHash","nodeHandle","layerNumber","nodeKey","result","w","join","toJSON","layersAsMath","key","Function","neuralNetwork","trainStream","checkFns","filter","c"],"mappings":"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","file":"neural-network.js","sourcesContent":["import lookup from './lookup';\nimport TrainStream from './train-stream';\nimport max from './utilities/max';\nimport mse from './utilities/mse';\nimport randos from './utilities/randos';\nimport range from './utilities/range';\nimport toArray from './utilities/to-array';\nimport zeros from './utilities/zeros';\nimport Thaw from 'thaw.js';\n\n/**\n * @param {object} options\n * @constructor\n */\nexport default class NeuralNetwork {\n  static get trainDefaults() {\n    return {\n      iterations: 20000,    // the maximum times to iterate the training data\n      errorThresh: 0.005,   // the acceptable error percentage from training data\n      log: false,           // true to use console.log, when a function is supplied it is used\n      logPeriod: 10,        // iterations between logging out\n      learningRate: 0.3,    // multiply's against the input and the delta then adds to momentum\n      momentum: 0.1,        // multiply's against the specified \"change\" then adds to learning rate for change\n      callback: null,       // a periodic call back that can be triggered while training\n      callbackPeriod: 10,   // the number of iterations through the training data between callback calls\n      timeout: Infinity     // the max number of milliseconds to train for\n    };\n  }\n\n  static get defaults() {\n    return {\n      binaryThresh: 0.5,     // ¯\\_(ツ)_/¯\n      hiddenLayers: [3],     // array of ints for the sizes of the hidden layers in the network\n      activation: 'sigmoid'  // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n    };\n  }\n\n  constructor(options = {}) {\n    Object.assign(this, this.constructor.defaults, options);\n    this.hiddenSizes = options.hiddenLayers;\n    this.trainOpts = {};\n    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));\n\n    this.sizes = null;\n    this.outputLayer = null;\n    this.biases = null; // weights for bias nodes\n    this.weights = null;\n    this.outputs = null;\n\n    // state for training\n    this.deltas = null;\n    this.changes = null; // for momentum\n    this.errors = null;\n\n    if (!this.constructor.prototype.hasOwnProperty('runInput')) {\n      this.runInput = null;\n    }\n    if (!this.constructor.prototype.hasOwnProperty('calculateDeltas')) {\n      this.calculateDeltas = null;\n    }\n  }\n\n  /**\n   *\n   * Expects this.sizes to have been set\n   */\n  _initialize() {\n    if (!this.sizes) throw new Error ('Sizes must be set before initializing')\n\n    this.outputLayer = this.sizes.length - 1;\n    this.biases = []; // weights for bias nodes\n    this.weights = [];\n    this.outputs = [];\n\n    // state for training\n    this.deltas = [];\n    this.changes = []; // for momentum\n    this.errors = [];\n\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      let size = this.sizes[layer];\n      this.deltas[layer] = zeros(size);\n      this.errors[layer] = zeros(size);\n      this.outputs[layer] = zeros(size);\n\n      if (layer > 0) {\n        this.biases[layer] = randos(size);\n        this.weights[layer] = new Array(size);\n        this.changes[layer] = new Array(size);\n\n        for (let node = 0; node < size; node++) {\n          let prevSize = this.sizes[layer - 1];\n          this.weights[layer][node] = randos(prevSize);\n          this.changes[layer][node] = zeros(prevSize);\n        }\n      }\n    }\n\n    this.setActivation();\n  }\n\n  /**\n   *\n   * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  setActivation(activation) {\n    this.activation = (activation) ? activation : this.activation;\n    switch (this.activation) {\n      case 'sigmoid':\n        this.runInput = this.runInput || this.runInputSigmoid;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;\n        break;\n      case 'relu':\n        this.runInput = this.runInput || this.runInputRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;\n        break;\n      case 'leaky-relu':\n        this.runInput = this.runInput || this.runInputLeakyRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;\n        break;\n      case 'tanh':\n        this.runInput = this.runInput || this.runInputTanh;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;\n        break;\n      default:\n        throw new Error('unknown activation ' + this.activation);\n    }\n  }\n\n  /**\n   *\n   * @returns boolean\n   */\n  get isRunnable(){\n    if(!this.runInput){\n      console.error('Activation function has not been initialized, did you run train()?');\n      return false;\n    }\n\n    const checkFns = [\n      'sizes',\n      'outputLayer',\n      'biases',\n      'weights',\n      'outputs',\n      'deltas',\n      'changes',\n      'errors',\n    ].filter(c => this[c] === null);\n\n    if(checkFns.length > 0){\n      console.error(`Some settings have not been initialized correctly, did you run train()? Found issues with: ${checkFns.join(', ')}`);\n      return false;\n    }\n    return true;\n  }\n\n\n  /**\n   *\n   * @param input\n   * @returns {*}\n   */\n  run(input) {\n    if (!this.isRunnable) return null;\n    if (this.inputLookup) {\n      input = lookup.toArray(this.inputLookup, input);\n    }\n\n    let output = [...this.runInput(input)];\n\n    if (this.outputLookup) {\n      output = lookup.toHash(this.outputLookup, output);\n    }\n    return output;\n  }\n\n  /**\n   * trains via sigmoid\n   * @param input\n   * @returns {*}\n   */\n  runInputSigmoid(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //sigmoid\n        this.outputs[layer][node] = 1 / (1 + Math.exp(-sum));\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputLeakyRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //leaky relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : 0.01 * sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputTanh(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //tanh\n        this.outputs[layer][node] = Math.tanh(sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  /**\n   *\n   * @param data\n   * Verifies network sizes are initilaized\n   * If they are not it will initialize them based off the data set.\n   */\n  _verifyIsInitialized(data) {\n    if (this.sizes) return;\n\n    this.sizes = [];\n    this.sizes.push(data[0].input.length);\n    if (!this.hiddenSizes) {\n      this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));\n    } else {\n      this.hiddenSizes.forEach(size => {\n        this.sizes.push(size);\n      });\n    }\n    this.sizes.push(data[0].output.length)\n\n    this._initialize();\n  }\n\n  /**\n   *\n   * @param options\n   *    Supports all `trainDefaults` properties\n   *    also supports:\n   *       learningRate: (number),\n   *       momentum: (number),\n   *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  updateTrainingOptions(opts) {\n    if (opts.iterations) { this.trainOpts.iterations = opts.iterations; }\n    if (opts.errorThresh) { this.trainOpts.errorThresh = opts.errorThresh; }\n    if (opts.log) { this._setLogMethod(opts.log); }\n    if (opts.logPeriod) { this.trainOpts.logPeriod = opts.logPeriod; }\n    if (opts.learningRate) { this.trainOpts.learningRate = opts.learningRate; }\n    if (opts.momentum) { this.trainOpts.momentum = opts.momentum; }\n    if (opts.callback) { this.trainOpts.callback = opts.callback; }\n    if (opts.callbackPeriod) { this.trainOpts.callbackPeriod = opts.callbackPeriod; }\n    if (opts.timeout) { this.trainOpts.timeout = opts.timeout; }\n    if (opts.activation) { this.activation = opts.activation; }\n  }\n\n  /**\n   *\n   *  Gets JSON of trainOpts object\n   *    NOTE: Activation is stored directly on JSON object and not in the training options\n   */\n  _getTrainOptsJSON() {\n    let results = {}\n    if (this.trainOpts.iterations) { results.iterations = this.trainOpts.iterations; }\n    if (this.trainOpts.errorThresh) { results.errorThresh = this.trainOpts.errorThresh; }\n    if (this.trainOpts.logPeriod) { results.logPeriod = this.trainOpts.logPeriod; }\n    if (this.trainOpts.learningRate) { results.learningRate = this.trainOpts.learningRate; }\n    if (this.trainOpts.momentum) { results.momentum = this.trainOpts.momentum; }\n    if (this.trainOpts.callback) { results.callback = this.trainOpts.callback; }\n    if (this.trainOpts.callbackPeriod) { results.callbackPeriod = this.trainOpts.callbackPeriod; }\n    if (this.trainOpts.timeout) { results.timeout = this.trainOpts.timeout; }\n    if (this.trainOpts.log) { results.log = true; }\n    return results;\n  }\n\n  /**\n   *\n   * @param log\n   * if a method is passed in method is used\n   * if false passed in nothing is logged\n   * @returns error\n   */\n  _setLogMethod(log) {\n    if (typeof log === 'function'){\n      this.trainOpts.log = log;\n    } else if (log) {\n      this.trainOpts.log = console.log;\n    } else {\n      this.trainOpts.log = false;\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param learning Rate\n   * @returns error\n   */\n  _calculateTrainingError(data) {\n    let sum = 0;\n    for (let i = 0; i < data.length; ++i) {\n      sum += this._trainPattern(data[i].input, data[i].output);\n    }\n    return sum / data.length;\n  }\n\n  /**\n   *\n   * @param status { iterations: number, error: number}\n   * @param options\n   */\n  _trainingTick(data, status) {\n    status.iterations++;\n    status.error = this._calculateTrainingError(data);\n\n    if (this.trainOpts.log && (status.iterations % this.trainOpts.logPeriod === 0)) {\n      this.trainOpts.log(`iterations: ${status.iterations}, training error: ${status.error}`);\n    }\n\n    if (this.trainOpts.callback && (status.iterations % this.trainOpts.callbackPeriod === 0)) {\n      this.trainOpts.callback(Object.assign(status));\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @returns {{error: number, iterations: number}}\n   */\n  train(data, options = {}) {\n    this.updateTrainingOptions(options);\n    data = this.formatData(data);\n    const endTime = Date.now() + this.trainOpts.timeout;\n\n    const status = {\n      error: 1,\n      iterations: 0\n    };\n\n    this._verifyIsInitialized(data);\n\n    while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {\n      this._trainingTick(data, status);\n    }\n\n    return status;\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @param cb\n   * @returns {{error: number, iterations: number}}\n   */\n  trainAsync(data, options = {}) {\n    return new Promise((resolve, reject) => {\n      this.updateTrainingOptions(options);\n      data = this.formatData(data);\n      const endTime = Date.now() + this.trainOpts.timeout;\n\n      const status = {\n        error: 1,\n        iterations: 0\n      };\n\n      this._verifyIsInitialized(data);\n\n      const items = new Array(this.trainOpts.iterations);\n      const thaw  = new Thaw(items, {\n        delay: true,\n        each: () => {\n          this._trainingTick(data, status);\n          if (status.error < this.trainOpts.errorThresh || Date.now() > endTime) {\n            thaw.stop();\n          }\n        },\n        done: () => { resolve(status); }\n      });\n\n      thaw.tick();\n    });\n  }\n\n  /**\n   *\n   * @param input\n   * @param target\n   */\n  _trainPattern(input, target) {\n\n    // forward propagate\n    this.runInput(input);\n\n    // back propagate\n    this.calculateDeltas(target);\n    this.adjustWeights();\n\n    let error = mse(this.errors[this.outputLayer]);\n    return error;\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasSigmoid(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = error * output * (1 - output);\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasLeakyRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0.01 * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasTanh(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = (1 - output * output) * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * Changes weights of networks\n   */\n  adjustWeights() {\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      let incoming = this.outputs[layer - 1];\n\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let delta = this.deltas[layer][node];\n\n        for (let k = 0; k < incoming.length; k++) {\n          let change = this.changes[layer][node][k];\n\n          change = (this.trainOpts.learningRate * delta * incoming[k])\n            + (this.trainOpts.momentum * change);\n\n          this.changes[layer][node][k] = change;\n          this.weights[layer][node][k] += change;\n        }\n        this.biases[layer][node] += this.trainOpts.learningRate * delta;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {*}\n   */\n  formatData(data) {\n    if (!Array.isArray(data)) { // turn stream datum into array\n      let tmp = [];\n      tmp.push(data);\n      data = tmp;\n    }\n    // turn sparse hash input into arrays with 0s as filler\n    let datum = data[0].input;\n    if (!Array.isArray(datum) && !(datum instanceof Float32Array)) {\n      if (!this.inputLookup) {\n        this.inputLookup = lookup.buildLookup(data.map(value => value['input']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.inputLookup, datum.input);\n        return Object.assign({}, datum, { input: array });\n      }, this);\n    }\n\n    if (!Array.isArray(data[0].output)) {\n      if (!this.outputLookup) {\n        this.outputLookup = lookup.buildLookup(data.map(value => value['output']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.outputLookup, datum.output);\n        return Object.assign({}, datum, { output: array });\n      }, this);\n    }\n    return data;\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {\n   *  {\n   *    error: number,\n   *    misclasses: Array\n   *  }\n   * }\n   */\n  test(data) {\n    data = this.formatData(data);\n\n    // for binary classification problems with one output node\n    let isBinary = data[0].output.length === 1;\n    let falsePos = 0;\n    let falseNeg = 0;\n    let truePos = 0;\n    let trueNeg = 0;\n\n    // for classification problems\n    let misclasses = [];\n\n    // run each pattern through the trained network and collect\n    // error and misclassification statistics\n    let sum = 0;\n    for (let i = 0; i < data.length; i++) {\n      let output = this.runInput(data[i].input);\n      let target = data[i].output;\n\n      let actual, expected;\n      if (isBinary) {\n        actual = output[0] > this.binaryThresh ? 1 : 0;\n        expected = target[0];\n      }\n      else {\n        actual = output.indexOf(max(output));\n        expected = target.indexOf(max(target));\n      }\n\n      if (actual !== expected) {\n        let misclass = data[i];\n        Object.assign(misclass, {\n          actual: actual,\n          expected: expected\n        });\n        misclasses.push(misclass);\n      }\n\n      if (isBinary) {\n        if (actual === 0 && expected === 0) {\n          trueNeg++;\n        } else if (actual === 1 && expected === 1) {\n          truePos++;\n        } else if (actual === 0 && expected === 1) {\n          falseNeg++;\n        } else if (actual === 1 && expected === 0) {\n          falsePos++;\n        }\n      }\n\n      let errors = output.map((value, i) => {\n        return target[i] - value;\n      });\n      sum += mse(errors);\n    }\n    let error = sum / data.length;\n\n    let stats = {\n      error: error,\n      misclasses: misclasses\n    };\n\n    if (isBinary) {\n      Object.assign(stats, {\n        trueNeg: trueNeg,\n        truePos: truePos,\n        falseNeg: falseNeg,\n        falsePos: falsePos,\n        total: data.length,\n        precision: truePos / (truePos + falsePos),\n        recall: truePos / (truePos + falseNeg),\n        accuracy: (trueNeg + truePos) / data.length\n      });\n    }\n    return stats;\n  }\n\n  /**\n   *\n   * @returns\n   *  {\n   *    layers: [\n   *      {\n   *        x: {},\n   *        y: {}\n   *      },\n   *      {\n   *        '0': {\n   *          bias: -0.98771313,\n   *          weights: {\n   *            x: 0.8374838,\n   *            y: 1.245858\n   *          },\n   *        '1': {\n   *          bias: 3.48192004,\n   *          weights: {\n   *            x: 1.7825821,\n   *            y: -2.67899\n   *          }\n   *        }\n   *      },\n   *      {\n   *        f: {\n   *          bias: 0.27205739,\n   *          weights: {\n   *            '0': 1.3161821,\n   *            '1': 2.00436\n   *          }\n   *        }\n   *      }\n   *    ]\n   *  }\n   */\n  toJSON() {\n    let layers = [];\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      layers[layer] = {};\n\n      let nodes;\n      // turn any internal arrays back into hashes for readable json\n      if (layer === 0 && this.inputLookup) {\n        nodes = Object.keys(this.inputLookup);\n      }\n      else if (layer === this.outputLayer && this.outputLookup) {\n        nodes = Object.keys(this.outputLookup);\n      }\n      else {\n        nodes = range(0, this.sizes[layer]);\n      }\n\n      for (let j = 0; j < nodes.length; j++) {\n        let node = nodes[j];\n        layers[layer][node] = {};\n\n        if (layer > 0) {\n          layers[layer][node].bias = this.biases[layer][j];\n          layers[layer][node].weights = {};\n          for (let k in layers[layer - 1]) {\n            let index = k;\n            if (layer === 1 && this.inputLookup) {\n              index = this.inputLookup[k];\n            }\n            layers[layer][node].weights[k] = this.weights[layer][j][index];\n          }\n        }\n      }\n    }\n    return {\n      sizes: this.sizes,\n      layers,\n      outputLookup:!!this.outputLookup,\n      inputLookup:!!this.inputLookup,\n      activation: this.activation,\n      trainOpts: this._getTrainOptsJSON()\n    };\n  }\n\n  /**\n   *\n   * @param json\n   * @returns {NeuralNetwork}\n   */\n  fromJSON (json) {\n    this.sizes = json.sizes\n    this._initialize();\n\n    for (let i = 0; i <= this.outputLayer; i++) {\n      let layer = json.layers[i];\n      if (i === 0 && (!layer[0] || json.inputLookup)) {\n        this.inputLookup = lookup.lookupFromHash(layer);\n      }\n      else if (i === this.outputLayer && (!layer[0] || json.outputLookup)) {\n        this.outputLookup = lookup.lookupFromHash(layer);\n      }\n      if (i > 0) {\n        const nodes = Object.keys(layer);\n        this.sizes[i] = nodes.length;\n        for (let j in nodes) {\n          const node = nodes[j];\n          this.biases[i][j] = layer[node].bias;\n          this.weights[i][j] = toArray(layer[node].weights);\n        }\n      }\n    }\n    this.updateTrainingOptions(json.trainOpts)\n    this.setActivation();\n    return this;\n  }\n\n  /**\n   *\n   * @returns {Function}\n   */\n  toFunction() {\n    const activation = this.activation;\n    function nodeHandle(layers, layerNumber, nodeKey) {\n      if (layerNumber === 0) {\n        return (typeof nodeKey === 'string'\n          ? `input['${nodeKey}']`\n          : `input[${nodeKey}]`);\n      }\n\n      const layer = layers[layerNumber];\n      const node = layer[nodeKey];\n      let result = [node.bias];\n      for (let w in node.weights) {\n        if (node.weights[w] < 0) {\n          result.push(`${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        } else {\n          result.push(`+${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        }\n      }\n\n      switch (activation) {\n        case 'sigmoid':\n          return `1/(1+1/Math.exp(${result.join('')}))`;\n        case 'relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : sum);`;\n        case 'leaky-relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : 0.01 * sum);`;\n        case 'tanh':\n          return `Math.tanh(${result.join('')});`;\n        default:\n          throw new Error('unknown activation type ' + activation);\n      }\n    }\n\n    const layers = this.toJSON().layers;\n    const layersAsMath = [];\n    let result;\n    for (let i in layers[layers.length - 1]) {\n      layersAsMath.push(nodeHandle(layers, layers.length - 1, i));\n    }\n    if (this.outputLookup) {\n      result = `{${\n        Object.keys(this.outputLookup)\n          .map((key, i) => `'${key}':${layersAsMath[i]}`)\n      }}`;\n    } else {\n      result = `[${layersAsMath.join(',')}]`;\n    }\n    return new Function('input', `return ${result}`);\n  }\n\n  /**\n   * This will create a TrainStream (WriteStream) for us to send the training data to.\n   * @param opts training options\n   * @returns {TrainStream|*}\n   */\n  createTrainStream(opts) {\n    opts = opts || {};\n    opts.neuralNetwork = this;\n    this.setActivation();\n    this.trainStream = new TrainStream(opts);\n    return this.trainStream;\n  }\n}"]}
\ No newline at end of file
diff --git a/test/base/json.js b/test/base/json.js
index 48c685518..2a274af66 100644
--- a/test/base/json.js
+++ b/test/base/json.js
@@ -1,6 +1,25 @@
 import assert from 'assert';
 import NeuralNetwork from './../../src/neural-network';
 
+let jsonNetwork = { sizes: [ 3, 3, 2 ],
+  layers: 
+   [ { r: {}, g: {}, b: {} },
+     { '0': [Object], '1': [Object], '2': [Object] },
+     { black: [Object], white: [Object] } ],
+  outputLookup: true,
+  inputLookup: true,
+  activation: 'relu',
+  trainOpts: {
+    iterations: 200,
+    errorThresh: 0.025,
+    logPeriod: 6,
+    learningRate: 0.4,
+    momentum: 0.2,
+    callbackPeriod: 3,
+    timeout: 500
+  }
+};
+
 describe('JSON', () => {
   const originalNet = new NeuralNetwork();
 

From 0d1a1108675d0e4bd4664fe46366ce9e33581bf3 Mon Sep 17 00:00:00 2001
From: Fred Christensen <fred@ifit.com>
Date: Tue, 30 Jan 2018 00:10:26 -0700
Subject: [PATCH 4/5] Updates the json test as well as doing a make.

---
 browser.js                 |  66 +++++++++++-----------
 browser.min.js             |   2 +-
 dist/neural-network.js     |  66 +++++++++++-----------
 dist/neural-network.js.map |   2 +-
 src/neural-network.js      |  46 +++++++--------
 test/base/json.js          | 111 ++++++++++++++++++++++++++++++-------
 test/base/trainopts.js     |  10 ++--
 7 files changed, 187 insertions(+), 116 deletions(-)

diff --git a/browser.js b/browser.js
index 29bf945cd..28c64a01b 100644
--- a/browser.js
+++ b/browser.js
@@ -1012,23 +1012,23 @@ var NeuralNetwork = function () {
       this.activation = activation ? activation : this.activation;
       switch (this.activation) {
         case 'sigmoid':
-          this.runInput = this.runInput || this.runInputSigmoid;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;
+          this.runInput = this.runInput || this._runInputSigmoid;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasSigmoid;
           break;
         case 'relu':
-          this.runInput = this.runInput || this.runInputRelu;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;
+          this.runInput = this.runInput || this._runInputRelu;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasRelu;
           break;
         case 'leaky-relu':
-          this.runInput = this.runInput || this.runInputLeakyRelu;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;
+          this.runInput = this.runInput || this._runInputLeakyRelu;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasLeakyRelu;
           break;
         case 'tanh':
-          this.runInput = this.runInput || this.runInputTanh;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;
+          this.runInput = this.runInput || this._runInputTanh;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasTanh;
           break;
         default:
-          throw new Error('unknown activation ' + this.activation);
+          throw new Error('unknown activation ' + this.activation + ', The activation should be one of [\'sigmoid\', \'relu\', \'leaky-relu\', \'tanh\']');
       }
     }
 
@@ -1067,8 +1067,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'runInputSigmoid',
-    value: function runInputSigmoid(input) {
+    key: '_runInputSigmoid',
+    value: function _runInputSigmoid(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -1088,8 +1088,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputRelu',
-    value: function runInputRelu(input) {
+    key: '_runInputRelu',
+    value: function _runInputRelu(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -1109,8 +1109,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputLeakyRelu',
-    value: function runInputLeakyRelu(input) {
+    key: '_runInputLeakyRelu',
+    value: function _runInputLeakyRelu(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -1130,8 +1130,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputTanh',
-    value: function runInputTanh(input) {
+    key: '_runInputTanh',
+    value: function _runInputTanh(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -1335,7 +1335,7 @@ var NeuralNetwork = function () {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       this.updateTrainingOptions(options);
-      data = this.formatData(data);
+      data = this._formatData(data);
       var endTime = Date.now() + this.trainOpts.timeout;
 
       var status = {
@@ -1369,7 +1369,7 @@ var NeuralNetwork = function () {
 
       return new Promise(function (resolve, reject) {
         _this2.updateTrainingOptions(options);
-        data = _this2.formatData(data);
+        data = _this2._formatData(data);
         var endTime = Date.now() + _this2.trainOpts.timeout;
 
         var status = {
@@ -1412,7 +1412,7 @@ var NeuralNetwork = function () {
 
       // back propagate
       this.calculateDeltas(target);
-      this.adjustWeights();
+      this._adjustWeights();
 
       var error = (0, _mse2.default)(this.errors[this.outputLayer]);
       return error;
@@ -1424,8 +1424,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasSigmoid',
-    value: function calculateDeltasSigmoid(target) {
+    key: '_calculateDeltasSigmoid',
+    value: function _calculateDeltasSigmoid(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -1451,8 +1451,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasRelu',
-    value: function calculateDeltasRelu(target) {
+    key: '_calculateDeltasRelu',
+    value: function _calculateDeltasRelu(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -1478,8 +1478,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasLeakyRelu',
-    value: function calculateDeltasLeakyRelu(target) {
+    key: '_calculateDeltasLeakyRelu',
+    value: function _calculateDeltasLeakyRelu(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -1505,8 +1505,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasTanh',
-    value: function calculateDeltasTanh(target) {
+    key: '_calculateDeltasTanh',
+    value: function _calculateDeltasTanh(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -1532,8 +1532,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'adjustWeights',
-    value: function adjustWeights() {
+    key: '_adjustWeights',
+    value: function _adjustWeights() {
       for (var layer = 1; layer <= this.outputLayer; layer++) {
         var incoming = this.outputs[layer - 1];
 
@@ -1560,8 +1560,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'formatData',
-    value: function formatData(data) {
+    key: '_formatData',
+    value: function _formatData(data) {
       var _this3 = this;
 
       if (!Array.isArray(data)) {
@@ -1614,7 +1614,7 @@ var NeuralNetwork = function () {
     value: function test(data) {
       var _this4 = this;
 
-      data = this.formatData(data);
+      data = this._formatData(data);
 
       // for binary classification problems with one output node
       var isBinary = data[0].output.length === 1;
diff --git a/browser.min.js b/browser.min.js
index 05aa40c06..14b6e0c80 100644
--- a/browser.min.js
+++ b/browser.min.js
@@ -123,7 +123,7 @@
 "use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var e=0,r=Array(t.length);e<t.length;e++)r[e]=t[e];return r}return Array.from(t)}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}function _inherits(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}function weightedSumSigmoid(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return 1/(1+Math.exp(-a))}function weightedSumRelu(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return a<0?0:a}function weightedSumLeakyRelu(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return a<0?0:.01*a}function weightedSumTanh(t,e,r){for(var a=e[this.thread.x],u=0;u<this.constants.size;u++)a+=t[this.thread.x][u]*r[u];return Math.tanh(a)}function calcErrorOutput(t,e){return e[this.thread.x]-t}function calcDeltasSigmoid(t,e){return t*e*(1-e)}function calcDeltasRelu(t,e){return e>0?t:0}function calcDeltasLeakyRelu(t,e){return e>0?t:.01*t}function calcDeltasTanh(t,e){return(1-e*e)*t}function calcError(t,e){for(var r=0,a=0;a<this.constants.size;a++)r+=e[a]*t[a][this.thread.x];return r}function calcChanges(t,e,r,a,u){return a*e[this.thread.y]*r[this.thread.x]+u*t[this.thread.y][this.thread.x]}function addWeights(t,e){return t+e[this.thread.y][this.thread.x]}function addBiases(t,e,r){return t[this.thread.x]+e[this.thread.x]*r}function mse(t){for(var e=0,r=0;r<this.constants.size;r++)e+=Math.pow(t[r],2);return e/this.constants.size}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,e){for(var r=0;r<e.length;r++){var a=e[r];a.enumerable=a.enumerable||!1,a.configurable=!0,"value"in a&&(a.writable=!0),Object.defineProperty(t,a.key,a)}}return function(e,r,a){return r&&t(e.prototype,r),a&&t(e,a),e}}(),_get=function t(e,r,a){null===e&&(e=Function.prototype);var u=Object.getOwnPropertyDescriptor(e,r);if(void 0===u){var i=Object.getPrototypeOf(e);return null===i?void 0:t(i,r,a)}if("value"in u)return u.value;var s=u.get;if(void 0!==s)return s.call(a)},_neuralNetwork=require("./neural-network"),_neuralNetwork2=_interopRequireDefault(_neuralNetwork),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_gpu=require("gpu.js"),_gpu2=_interopRequireDefault(_gpu),NeuralNetworkGPU=function(t){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,e);var r=_possibleConstructorReturn(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t));return r.forwardPropagate=[],r.backwardPropagate=[],r.changesPropagate=[],r.biasesPropagate=[],r.gpu=new _gpu2.default({mode:t.mode}),r}return _inherits(e,t),_createClass(e,[{key:"initialize",value:function(t){_get(e.prototype.__proto__||Object.getPrototypeOf(e.prototype),"initialize",this).call(this,t),this.buildRunInput(),this.buildCalculateDeltas(),this.buildGetChanges(),this.buildChangeBiases(),this.buildGetMSE()}},{key:"setActivation",value:function(){}},{key:"trainPattern",value:function(t,e,r){return r=r||this.learningRate,this.runInput(t),this.calculateDeltas(e),this.getChanges(r),this.changeBiases(r),this.getMSE(this.errors[this.outputLayer])[0]}},{key:"buildRunInput",value:function(){var t=null;switch(this.activation){case"sigmoid":t=weightedSumSigmoid;break;case"relu":t=weightedSumRelu;break;case"leaky-relu":t=weightedSumLeakyRelu;break;case"tanh":t=weightedSumTanh;break;default:throw new Error("unknown activation "+this.activation)}for(var e=1;e<=this.outputLayer;e++)this.forwardPropagate[e]=this.gpu.createKernel(t,{output:[this.sizes[e]],outputToTexture:!0,constants:{size:this.sizes[e-1]}})}},{key:"runInput",value:function(t){var e=void 0;this.outputs[0]=t;for(var r=1;r<=this.outputLayer;r++)this.outputs[r]=this.forwardPropagate[r](this.weights[r],this.biases[r],t),e=t=this.outputs[r];return e}},{key:"buildCalculateDeltas",value:function(){var t=null;switch(this.activation){case"sigmoid":t=calcDeltasSigmoid;break;case"relu":t=calcDeltasRelu;break;case"leaky-relu":t=calcDeltasLeakyRelu;break;case"tanh":t=calcDeltasTanh;break;default:throw new Error("unknown activation "+this.activation)}for(var e=this.outputLayer;e>0;e--)e===this.outputLayer?this.backwardPropagate[e]=this.gpu.createKernelMap({error:_gpu2.default.alias("calcErrorOutput",calcErrorOutput),deltas:_gpu2.default.alias("calcDeltas",t)},function(e,r){var a=e[this.thread.x];return t(calcErrorOutput(a,r),a)},{output:[this.sizes[e]],outputToTexture:!0}):this.backwardPropagate[e]=this.gpu.createKernelMap({error:_gpu2.default.alias("calcError",calcError),deltas:_gpu2.default.alias("calcDeltas",t)},function(e,r,a){var u=r[this.thread.x];return t(calcError(e,a),u)},{output:[this.sizes[e]],outputToTexture:!0,constants:{size:this.deltas[e+1].length}})}},{key:"calculateDeltas",value:function(t,e){for(var r=this.outputLayer;r>0;r--){var a=void 0;a=r===this.outputLayer?this.backwardPropagate[r](this.outputs[r],t):this.backwardPropagate[r](this.weights[r+1],this.outputs[r],this.deltas[r+1]),this.deltas[r]=a.deltas,this.errors[r]=a.error}}},{key:"buildGetChanges",value:function(){for(var t=1;t<=this.outputLayer;t++)this.changesPropagate[t]=this.gpu.createKernelMap({weights:_gpu2.default.alias("addWeights",addWeights),changes:_gpu2.default.alias("calcChanges",calcChanges)},function(t,e,r,a,u,i){return addWeights(calcChanges(a,e,t,u,i),r)},{output:[this.sizes[t-1],this.sizes[t]],outputToTexture:!0,constants:{size:this.outputs[t-1].length}})}},{key:"getChanges",value:function(t){for(var e=1;e<=this.outputLayer;e++){var r=this.changesPropagate[e](this.outputs[e-1],this.deltas[e],this.weights[e],this.changes[e],t,this.momentum);this.changes[e]=r.changes,this.weights[e]=r.weights}}},{key:"buildChangeBiases",value:function(){for(var t=1;t<=this.outputLayer;t++)this.biasesPropagate[t]=this.gpu.createKernel(addBiases,{output:[this.sizes[t]],outputToTexture:!0})}},{key:"changeBiases",value:function(t){for(var e=1;e<=this.outputLayer;e++)this.biases[e]=this.biasesPropagate[e](this.biases[e],this.deltas[e],t)}},{key:"buildGetMSE",value:function(){this.getMSE=this.gpu.createKernel(mse,{output:[1],constants:{size:this.outputLayer}})}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var e=[].concat(_toConsumableArray(this.runInput(t).toArray(this.gpu)));return this.outputLookup&&(e=_lookup2.default.toHash(this.outputLookup,e)),e}},{key:"formatData",value:function(t){var e=this;if(!Array.isArray(t)){var r=[];r.push(t),t=r}var a=t[0].input;return Array.isArray(a)||a instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var r=_lookup2.default.toArray(e.inputLookup,t.input);return Object.assign({},t,{input:r})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var r=_lookup2.default.toArray(e.outputLookup,t.output);return Object.assign({},t,{output:r})},this)),t}},{key:"toFunction",value:function(){throw new Error("not implemented on NeuralNetworkGPU")}}]),e}(_neuralNetwork2.default);exports.default=NeuralNetworkGPU;
 
 },{"./lookup":3,"./neural-network":5,"gpu.js":76}],5:[function(require,module,exports){
-"use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var i=0,e=Array(t.length);i<t.length;i++)e[i]=t[i];return e}return Array.from(t)}function _classCallCheck(t,i){if(!(t instanceof i))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,i){for(var e=0;e<i.length;e++){var r=i[e];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(i,e,r){return e&&t(i.prototype,e),r&&t(i,r),i}}(),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_trainStream=require("./train-stream"),_trainStream2=_interopRequireDefault(_trainStream),_max=require("./utilities/max"),_max2=_interopRequireDefault(_max),_mse=require("./utilities/mse"),_mse2=_interopRequireDefault(_mse),_randos=require("./utilities/randos"),_randos2=_interopRequireDefault(_randos),_range=require("./utilities/range"),_range2=_interopRequireDefault(_range),_toArray=require("./utilities/to-array"),_toArray2=_interopRequireDefault(_toArray),_zeros=require("./utilities/zeros"),_zeros2=_interopRequireDefault(_zeros),_thaw=require("thaw.js"),_thaw2=_interopRequireDefault(_thaw),NeuralNetwork=function(){function t(){var i=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,t),Object.assign(this,this.constructor.defaults,i),this.hiddenSizes=i.hiddenLayers,this.trainOpts={},this.updateTrainingOptions(Object.assign({},this.constructor.trainDefaults,i)),this.sizes=null,this.outputLayer=null,this.biases=null,this.weights=null,this.outputs=null,this.deltas=null,this.changes=null,this.errors=null,this.constructor.prototype.hasOwnProperty("runInput")||(this.runInput=null),this.constructor.prototype.hasOwnProperty("calculateDeltas")||(this.calculateDeltas=null)}return _createClass(t,null,[{key:"trainDefaults",get:function(){return{iterations:2e4,errorThresh:.005,log:!1,logPeriod:10,learningRate:.3,momentum:.1,callback:null,callbackPeriod:10,timeout:1/0}}},{key:"defaults",get:function(){return{binaryThresh:.5,hiddenLayers:[3],activation:"sigmoid"}}}]),_createClass(t,[{key:"_initialize",value:function(){if(!this.sizes)throw new Error("Sizes must be set before initializing");this.outputLayer=this.sizes.length-1,this.biases=[],this.weights=[],this.outputs=[],this.deltas=[],this.changes=[],this.errors=[];for(var t=0;t<=this.outputLayer;t++){var i=this.sizes[t];if(this.deltas[t]=(0,_zeros2.default)(i),this.errors[t]=(0,_zeros2.default)(i),this.outputs[t]=(0,_zeros2.default)(i),t>0){this.biases[t]=(0,_randos2.default)(i),this.weights[t]=new Array(i),this.changes[t]=new Array(i);for(var e=0;e<i;e++){var r=this.sizes[t-1];this.weights[t][e]=(0,_randos2.default)(r),this.changes[t][e]=(0,_zeros2.default)(r)}}}this.setActivation()}},{key:"setActivation",value:function(t){switch(this.activation=t||this.activation,this.activation){case"sigmoid":this.runInput=this.runInput||this.runInputSigmoid,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasSigmoid;break;case"relu":this.runInput=this.runInput||this.runInputRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasRelu;break;case"leaky-relu":this.runInput=this.runInput||this.runInputLeakyRelu,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasLeakyRelu;break;case"tanh":this.runInput=this.runInput||this.runInputTanh,this.calculateDeltas=this.calculateDeltas||this.calculateDeltasTanh;break;default:throw new Error("unknown activation "+this.activation)}}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var i=[].concat(_toConsumableArray(this.runInput(t)));return this.outputLookup&&(i=_lookup2.default.toHash(this.outputLookup,i)),i}},{key:"runInputSigmoid",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=1/(1+Math.exp(-a))}i=t=this.outputs[e]}return i}},{key:"runInputRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:a}i=t=this.outputs[e]}return i}},{key:"runInputLeakyRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:.01*a}i=t=this.outputs[e]}return i}},{key:"runInputTanh",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=Math.tanh(a)}i=t=this.outputs[e]}return i}},{key:"_verifyIsInitialized",value:function(t){var i=this;this.sizes||(this.sizes=[],this.sizes.push(t[0].input.length),this.hiddenSizes?this.hiddenSizes.forEach(function(t){i.sizes.push(t)}):this.sizes.push(Math.max(3,Math.floor(t[0].input.length/2))),this.sizes.push(t[0].output.length),this._initialize())}},{key:"updateTrainingOptions",value:function(t){t.iterations&&(this.trainOpts.iterations=t.iterations),t.errorThresh&&(this.trainOpts.errorThresh=t.errorThresh),t.log&&this._setLogMethod(t.log),t.logPeriod&&(this.trainOpts.logPeriod=t.logPeriod),t.learningRate&&(this.trainOpts.learningRate=t.learningRate),t.momentum&&(this.trainOpts.momentum=t.momentum),t.callback&&(this.trainOpts.callback=t.callback),t.callbackPeriod&&(this.trainOpts.callbackPeriod=t.callbackPeriod),t.timeout&&(this.trainOpts.timeout=t.timeout),t.activation&&(this.activation=t.activation)}},{key:"_getTrainOptsJSON",value:function(){var t={};return this.trainOpts.iterations&&(t.iterations=this.trainOpts.iterations),this.trainOpts.errorThresh&&(t.errorThresh=this.trainOpts.errorThresh),this.trainOpts.logPeriod&&(t.logPeriod=this.trainOpts.logPeriod),this.trainOpts.learningRate&&(t.learningRate=this.trainOpts.learningRate),this.trainOpts.momentum&&(t.momentum=this.trainOpts.momentum),this.trainOpts.callback&&(t.callback=this.trainOpts.callback),this.trainOpts.callbackPeriod&&(t.callbackPeriod=this.trainOpts.callbackPeriod),this.trainOpts.timeout&&(t.timeout=this.trainOpts.timeout),this.trainOpts.log&&(t.log=!0),t}},{key:"_setLogMethod",value:function(t){this.trainOpts.log="function"==typeof t?t:!!t&&console.log}},{key:"_calculateTrainingError",value:function(t){for(var i=0,e=0;e<t.length;++e)i+=this._trainPattern(t[e].input,t[e].output);return i/t.length}},{key:"_trainingTick",value:function(t,i){i.iterations++,i.error=this._calculateTrainingError(t),this.trainOpts.log&&i.iterations%this.trainOpts.logPeriod==0&&this.trainOpts.log("iterations: "+i.iterations+", training error: "+i.error),this.trainOpts.callback&&i.iterations%this.trainOpts.callbackPeriod==0&&this.trainOpts.callback(Object.assign(i))}},{key:"train",value:function(t){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.updateTrainingOptions(i),t=this.formatData(t);var e=Date.now()+this.trainOpts.timeout,r={error:1,iterations:0};for(this._verifyIsInitialized(t);r.iterations<this.trainOpts.iterations&&r.error>this.trainOpts.errorThresh&&Date.now()<e;)this._trainingTick(t,r);return r}},{key:"trainAsync",value:function(t){var i=this,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return new Promise(function(r,s){i.updateTrainingOptions(e),t=i.formatData(t);var a=Date.now()+i.trainOpts.timeout,n={error:1,iterations:0};i._verifyIsInitialized(t);var u=new Array(i.trainOpts.iterations),o=new _thaw2.default(u,{delay:!0,each:function(){i._trainingTick(t,n),(n.error<i.trainOpts.errorThresh||Date.now()>a)&&o.stop()},done:function(){r(n)}});o.tick()})}},{key:"_trainPattern",value:function(t,i){return this.runInput(t),this.calculateDeltas(i),this.adjustWeights(),(0,_mse2.default)(this.errors[this.outputLayer])}},{key:"calculateDeltasSigmoid",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=s*r*(1-r)}}},{key:"calculateDeltasRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:0}}},{key:"calculateDeltasLeakyRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:.01*s}}},{key:"calculateDeltasTanh",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=(1-r*r)*s}}},{key:"adjustWeights",value:function(){for(var t=1;t<=this.outputLayer;t++)for(var i=this.outputs[t-1],e=0;e<this.sizes[t];e++){for(var r=this.deltas[t][e],s=0;s<i.length;s++){var a=this.changes[t][e][s];a=this.trainOpts.learningRate*r*i[s]+this.trainOpts.momentum*a,this.changes[t][e][s]=a,this.weights[t][e][s]+=a}this.biases[t][e]+=this.trainOpts.learningRate*r}}},{key:"formatData",value:function(t){var i=this;if(!Array.isArray(t)){var e=[];e.push(t),t=e}var r=t[0].input;return Array.isArray(r)||r instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.inputLookup,t.input);return Object.assign({},t,{input:e})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.outputLookup,t.output);return Object.assign({},t,{output:e})},this)),t}},{key:"test",value:function(t){var i=this;t=this.formatData(t);for(var e=1===t[0].output.length,r=0,s=0,a=0,n=0,u=[],o=0,h=0;h<t.length;h++)!function(h){var l=i.runInput(t[h].input),p=t[h].output,c=void 0,f=void 0;if(e?(c=l[0]>i.binaryThresh?1:0,f=p[0]):(c=l.indexOf((0,_max2.default)(l)),f=p.indexOf((0,_max2.default)(p))),c!==f){var v=t[h];Object.assign(v,{actual:c,expected:f}),u.push(v)}e&&(0===c&&0===f?n++:1===c&&1===f?a++:0===c&&1===f?s++:1===c&&0===f&&r++);var g=l.map(function(t,i){return p[i]-t});o+=(0,_mse2.default)(g)}(h);var l=o/t.length,p={error:l,misclasses:u};return e&&Object.assign(p,{trueNeg:n,truePos:a,falseNeg:s,falsePos:r,total:t.length,precision:a/(a+r),recall:a/(a+s),accuracy:(n+a)/t.length}),p}},{key:"toJSON",value:function(){for(var t=[],i=0;i<=this.outputLayer;i++){t[i]={};var e=void 0;e=0===i&&this.inputLookup?Object.keys(this.inputLookup):i===this.outputLayer&&this.outputLookup?Object.keys(this.outputLookup):(0,_range2.default)(0,this.sizes[i]);for(var r=0;r<e.length;r++){var s=e[r];if(t[i][s]={},i>0){t[i][s].bias=this.biases[i][r],t[i][s].weights={};for(var a in t[i-1]){var n=a;1===i&&this.inputLookup&&(n=this.inputLookup[a]),t[i][s].weights[a]=this.weights[i][r][n]}}}}return{sizes:this.sizes,layers:t,outputLookup:!!this.outputLookup,inputLookup:!!this.inputLookup,activation:this.activation,trainOpts:this._getTrainOptsJSON()}}},{key:"fromJSON",value:function(t){this.sizes=t.sizes,this._initialize();for(var i=0;i<=this.outputLayer;i++){var e=t.layers[i];if(0!==i||e[0]&&!t.inputLookup?i!==this.outputLayer||e[0]&&!t.outputLookup||(this.outputLookup=_lookup2.default.lookupFromHash(e)):this.inputLookup=_lookup2.default.lookupFromHash(e),i>0){var r=Object.keys(e);this.sizes[i]=r.length;for(var s in r){var a=r[s];this.biases[i][s]=e[a].bias,this.weights[i][s]=(0,_toArray2.default)(e[a].weights)}}}return this.updateTrainingOptions(t.trainOpts),this.setActivation(),this}},{key:"toFunction",value:function(){function t(e,r,s){if(0===r)return"string"==typeof s?"input['"+s+"']":"input["+s+"]";var a=e[r],n=a[s],u=[n.bias];for(var o in n.weights)n.weights[o]<0?u.push(n.weights[o]+"*("+t(e,r-1,o)+")"):u.push("+"+n.weights[o]+"*("+t(e,r-1,o)+")");switch(i){case"sigmoid":return"1/(1+1/Math.exp("+u.join("")+"))";case"relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : sum);";case"leaky-relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : 0.01 * sum);";case"tanh":return"Math.tanh("+u.join("")+");";default:throw new Error("unknown activation type "+i)}}var i=this.activation,e=this.toJSON().layers,r=[],s=void 0;for(var a in e[e.length-1])r.push(t(e,e.length-1,a));return s=this.outputLookup?"{"+Object.keys(this.outputLookup).map(function(t,i){return"'"+t+"':"+r[i]})+"}":"["+r.join(",")+"]",new Function("input","return "+s)}},{key:"createTrainStream",value:function(t){return t=t||{},t.neuralNetwork=this,this.setActivation(),this.trainStream=new _trainStream2.default(t),this.trainStream}},{key:"isRunnable",get:function(){var t=this;if(!this.runInput)return console.error("Activation function has not been initialized, did you run train()?"),!1;var i=["sizes","outputLayer","biases","weights","outputs","deltas","changes","errors"].filter(function(i){return null===t[i]});return!(i.length>0)||(console.error("Some settings have not been initialized correctly, did you run train()? Found issues with: "+i.join(", ")),!1)}}]),t}();exports.default=NeuralNetwork;
+"use strict";function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}function _toConsumableArray(t){if(Array.isArray(t)){for(var i=0,e=Array(t.length);i<t.length;i++)e[i]=t[i];return e}return Array.from(t)}function _classCallCheck(t,i){if(!(t instanceof i))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function t(t,i){for(var e=0;e<i.length;e++){var r=i[e];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,r.key,r)}}return function(i,e,r){return e&&t(i.prototype,e),r&&t(i,r),i}}(),_lookup=require("./lookup"),_lookup2=_interopRequireDefault(_lookup),_trainStream=require("./train-stream"),_trainStream2=_interopRequireDefault(_trainStream),_max=require("./utilities/max"),_max2=_interopRequireDefault(_max),_mse=require("./utilities/mse"),_mse2=_interopRequireDefault(_mse),_randos=require("./utilities/randos"),_randos2=_interopRequireDefault(_randos),_range=require("./utilities/range"),_range2=_interopRequireDefault(_range),_toArray=require("./utilities/to-array"),_toArray2=_interopRequireDefault(_toArray),_zeros=require("./utilities/zeros"),_zeros2=_interopRequireDefault(_zeros),_thaw=require("thaw.js"),_thaw2=_interopRequireDefault(_thaw),NeuralNetwork=function(){function t(){var i=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};_classCallCheck(this,t),Object.assign(this,this.constructor.defaults,i),this.hiddenSizes=i.hiddenLayers,this.trainOpts={},this.updateTrainingOptions(Object.assign({},this.constructor.trainDefaults,i)),this.sizes=null,this.outputLayer=null,this.biases=null,this.weights=null,this.outputs=null,this.deltas=null,this.changes=null,this.errors=null,this.constructor.prototype.hasOwnProperty("runInput")||(this.runInput=null),this.constructor.prototype.hasOwnProperty("calculateDeltas")||(this.calculateDeltas=null)}return _createClass(t,null,[{key:"trainDefaults",get:function(){return{iterations:2e4,errorThresh:.005,log:!1,logPeriod:10,learningRate:.3,momentum:.1,callback:null,callbackPeriod:10,timeout:1/0}}},{key:"defaults",get:function(){return{binaryThresh:.5,hiddenLayers:[3],activation:"sigmoid"}}}]),_createClass(t,[{key:"_initialize",value:function(){if(!this.sizes)throw new Error("Sizes must be set before initializing");this.outputLayer=this.sizes.length-1,this.biases=[],this.weights=[],this.outputs=[],this.deltas=[],this.changes=[],this.errors=[];for(var t=0;t<=this.outputLayer;t++){var i=this.sizes[t];if(this.deltas[t]=(0,_zeros2.default)(i),this.errors[t]=(0,_zeros2.default)(i),this.outputs[t]=(0,_zeros2.default)(i),t>0){this.biases[t]=(0,_randos2.default)(i),this.weights[t]=new Array(i),this.changes[t]=new Array(i);for(var e=0;e<i;e++){var r=this.sizes[t-1];this.weights[t][e]=(0,_randos2.default)(r),this.changes[t][e]=(0,_zeros2.default)(r)}}}this.setActivation()}},{key:"setActivation",value:function(t){switch(this.activation=t||this.activation,this.activation){case"sigmoid":this.runInput=this.runInput||this._runInputSigmoid,this.calculateDeltas=this.calculateDeltas||this._calculateDeltasSigmoid;break;case"relu":this.runInput=this.runInput||this._runInputRelu,this.calculateDeltas=this.calculateDeltas||this._calculateDeltasRelu;break;case"leaky-relu":this.runInput=this.runInput||this._runInputLeakyRelu,this.calculateDeltas=this.calculateDeltas||this._calculateDeltasLeakyRelu;break;case"tanh":this.runInput=this.runInput||this._runInputTanh,this.calculateDeltas=this.calculateDeltas||this._calculateDeltasTanh;break;default:throw new Error("unknown activation "+this.activation+", The activation should be one of ['sigmoid', 'relu', 'leaky-relu', 'tanh']")}}},{key:"run",value:function(t){if(!this.isRunnable)return null;this.inputLookup&&(t=_lookup2.default.toArray(this.inputLookup,t));var i=[].concat(_toConsumableArray(this.runInput(t)));return this.outputLookup&&(i=_lookup2.default.toHash(this.outputLookup,i)),i}},{key:"_runInputSigmoid",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=1/(1+Math.exp(-a))}i=t=this.outputs[e]}return i}},{key:"_runInputRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:a}i=t=this.outputs[e]}return i}},{key:"_runInputLeakyRelu",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=a<0?0:.01*a}i=t=this.outputs[e]}return i}},{key:"_runInputTanh",value:function(t){this.outputs[0]=t;for(var i=null,e=1;e<=this.outputLayer;e++){for(var r=0;r<this.sizes[e];r++){for(var s=this.weights[e][r],a=this.biases[e][r],n=0;n<s.length;n++)a+=s[n]*t[n];this.outputs[e][r]=Math.tanh(a)}i=t=this.outputs[e]}return i}},{key:"_verifyIsInitialized",value:function(t){var i=this;this.sizes||(this.sizes=[],this.sizes.push(t[0].input.length),this.hiddenSizes?this.hiddenSizes.forEach(function(t){i.sizes.push(t)}):this.sizes.push(Math.max(3,Math.floor(t[0].input.length/2))),this.sizes.push(t[0].output.length),this._initialize())}},{key:"updateTrainingOptions",value:function(t){t.iterations&&(this.trainOpts.iterations=t.iterations),t.errorThresh&&(this.trainOpts.errorThresh=t.errorThresh),t.log&&this._setLogMethod(t.log),t.logPeriod&&(this.trainOpts.logPeriod=t.logPeriod),t.learningRate&&(this.trainOpts.learningRate=t.learningRate),t.momentum&&(this.trainOpts.momentum=t.momentum),t.callback&&(this.trainOpts.callback=t.callback),t.callbackPeriod&&(this.trainOpts.callbackPeriod=t.callbackPeriod),t.timeout&&(this.trainOpts.timeout=t.timeout),t.activation&&(this.activation=t.activation)}},{key:"_getTrainOptsJSON",value:function(){var t={};return this.trainOpts.iterations&&(t.iterations=this.trainOpts.iterations),this.trainOpts.errorThresh&&(t.errorThresh=this.trainOpts.errorThresh),this.trainOpts.logPeriod&&(t.logPeriod=this.trainOpts.logPeriod),this.trainOpts.learningRate&&(t.learningRate=this.trainOpts.learningRate),this.trainOpts.momentum&&(t.momentum=this.trainOpts.momentum),this.trainOpts.callback&&(t.callback=this.trainOpts.callback),this.trainOpts.callbackPeriod&&(t.callbackPeriod=this.trainOpts.callbackPeriod),this.trainOpts.timeout&&(t.timeout=this.trainOpts.timeout),this.trainOpts.log&&(t.log=!0),t}},{key:"_setLogMethod",value:function(t){this.trainOpts.log="function"==typeof t?t:!!t&&console.log}},{key:"_calculateTrainingError",value:function(t){for(var i=0,e=0;e<t.length;++e)i+=this._trainPattern(t[e].input,t[e].output);return i/t.length}},{key:"_trainingTick",value:function(t,i){i.iterations++,i.error=this._calculateTrainingError(t),this.trainOpts.log&&i.iterations%this.trainOpts.logPeriod==0&&this.trainOpts.log("iterations: "+i.iterations+", training error: "+i.error),this.trainOpts.callback&&i.iterations%this.trainOpts.callbackPeriod==0&&this.trainOpts.callback(Object.assign(i))}},{key:"train",value:function(t){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.updateTrainingOptions(i),t=this._formatData(t);var e=Date.now()+this.trainOpts.timeout,r={error:1,iterations:0};for(this._verifyIsInitialized(t);r.iterations<this.trainOpts.iterations&&r.error>this.trainOpts.errorThresh&&Date.now()<e;)this._trainingTick(t,r);return r}},{key:"trainAsync",value:function(t){var i=this,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return new Promise(function(r,s){i.updateTrainingOptions(e),t=i._formatData(t);var a=Date.now()+i.trainOpts.timeout,n={error:1,iterations:0};i._verifyIsInitialized(t);var u=new Array(i.trainOpts.iterations),o=new _thaw2.default(u,{delay:!0,each:function(){i._trainingTick(t,n),(n.error<i.trainOpts.errorThresh||Date.now()>a)&&o.stop()},done:function(){r(n)}});o.tick()})}},{key:"_trainPattern",value:function(t,i){return this.runInput(t),this.calculateDeltas(i),this._adjustWeights(),(0,_mse2.default)(this.errors[this.outputLayer])}},{key:"_calculateDeltasSigmoid",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=s*r*(1-r)}}},{key:"_calculateDeltasRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:0}}},{key:"_calculateDeltasLeakyRelu",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=r>0?s:.01*s}}},{key:"_calculateDeltasTanh",value:function(t){for(var i=this.outputLayer;i>=0;i--)for(var e=0;e<this.sizes[i];e++){var r=this.outputs[i][e],s=0;if(i===this.outputLayer)s=t[e]-r;else for(var a=this.deltas[i+1],n=0;n<a.length;n++)s+=a[n]*this.weights[i+1][n][e];this.errors[i][e]=s,this.deltas[i][e]=(1-r*r)*s}}},{key:"_adjustWeights",value:function(){for(var t=1;t<=this.outputLayer;t++)for(var i=this.outputs[t-1],e=0;e<this.sizes[t];e++){for(var r=this.deltas[t][e],s=0;s<i.length;s++){var a=this.changes[t][e][s];a=this.trainOpts.learningRate*r*i[s]+this.trainOpts.momentum*a,this.changes[t][e][s]=a,this.weights[t][e][s]+=a}this.biases[t][e]+=this.trainOpts.learningRate*r}}},{key:"_formatData",value:function(t){var i=this;if(!Array.isArray(t)){var e=[];e.push(t),t=e}var r=t[0].input;return Array.isArray(r)||r instanceof Float32Array||(this.inputLookup||(this.inputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.input}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.inputLookup,t.input);return Object.assign({},t,{input:e})},this)),Array.isArray(t[0].output)||(this.outputLookup||(this.outputLookup=_lookup2.default.buildLookup(t.map(function(t){return t.output}))),t=t.map(function(t){var e=_lookup2.default.toArray(i.outputLookup,t.output);return Object.assign({},t,{output:e})},this)),t}},{key:"test",value:function(t){var i=this;t=this._formatData(t);for(var e=1===t[0].output.length,r=0,s=0,a=0,n=0,u=[],o=0,h=0;h<t.length;h++)!function(h){var l=i.runInput(t[h].input),p=t[h].output,c=void 0,f=void 0;if(e?(c=l[0]>i.binaryThresh?1:0,f=p[0]):(c=l.indexOf((0,_max2.default)(l)),f=p.indexOf((0,_max2.default)(p))),c!==f){var v=t[h];Object.assign(v,{actual:c,expected:f}),u.push(v)}e&&(0===c&&0===f?n++:1===c&&1===f?a++:0===c&&1===f?s++:1===c&&0===f&&r++);var g=l.map(function(t,i){return p[i]-t});o+=(0,_mse2.default)(g)}(h);var l=o/t.length,p={error:l,misclasses:u};return e&&Object.assign(p,{trueNeg:n,truePos:a,falseNeg:s,falsePos:r,total:t.length,precision:a/(a+r),recall:a/(a+s),accuracy:(n+a)/t.length}),p}},{key:"toJSON",value:function(){for(var t=[],i=0;i<=this.outputLayer;i++){t[i]={};var e=void 0;e=0===i&&this.inputLookup?Object.keys(this.inputLookup):i===this.outputLayer&&this.outputLookup?Object.keys(this.outputLookup):(0,_range2.default)(0,this.sizes[i]);for(var r=0;r<e.length;r++){var s=e[r];if(t[i][s]={},i>0){t[i][s].bias=this.biases[i][r],t[i][s].weights={};for(var a in t[i-1]){var n=a;1===i&&this.inputLookup&&(n=this.inputLookup[a]),t[i][s].weights[a]=this.weights[i][r][n]}}}}return{sizes:this.sizes,layers:t,outputLookup:!!this.outputLookup,inputLookup:!!this.inputLookup,activation:this.activation,trainOpts:this._getTrainOptsJSON()}}},{key:"fromJSON",value:function(t){this.sizes=t.sizes,this._initialize();for(var i=0;i<=this.outputLayer;i++){var e=t.layers[i];if(0!==i||e[0]&&!t.inputLookup?i!==this.outputLayer||e[0]&&!t.outputLookup||(this.outputLookup=_lookup2.default.lookupFromHash(e)):this.inputLookup=_lookup2.default.lookupFromHash(e),i>0){var r=Object.keys(e);this.sizes[i]=r.length;for(var s in r){var a=r[s];this.biases[i][s]=e[a].bias,this.weights[i][s]=(0,_toArray2.default)(e[a].weights)}}}return this.updateTrainingOptions(t.trainOpts),this.setActivation(),this}},{key:"toFunction",value:function(){function t(e,r,s){if(0===r)return"string"==typeof s?"input['"+s+"']":"input["+s+"]";var a=e[r],n=a[s],u=[n.bias];for(var o in n.weights)n.weights[o]<0?u.push(n.weights[o]+"*("+t(e,r-1,o)+")"):u.push("+"+n.weights[o]+"*("+t(e,r-1,o)+")");switch(i){case"sigmoid":return"1/(1+1/Math.exp("+u.join("")+"))";case"relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : sum);";case"leaky-relu":return"var sum = "+u.join("")+";(sum < 0 ? 0 : 0.01 * sum);";case"tanh":return"Math.tanh("+u.join("")+");";default:throw new Error("unknown activation type "+i)}}var i=this.activation,e=this.toJSON().layers,r=[],s=void 0;for(var a in e[e.length-1])r.push(t(e,e.length-1,a));return s=this.outputLookup?"{"+Object.keys(this.outputLookup).map(function(t,i){return"'"+t+"':"+r[i]})+"}":"["+r.join(",")+"]",new Function("input","return "+s)}},{key:"createTrainStream",value:function(t){return t=t||{},t.neuralNetwork=this,this.setActivation(),this.trainStream=new _trainStream2.default(t),this.trainStream}},{key:"isRunnable",get:function(){var t=this;if(!this.runInput)return console.error("Activation function has not been initialized, did you run train()?"),!1;var i=["sizes","outputLayer","biases","weights","outputs","deltas","changes","errors"].filter(function(i){return null===t[i]});return!(i.length>0)||(console.error("Some settings have not been initialized correctly, did you run train()? Found issues with: "+i.join(", ")),!1)}}]),t}();exports.default=NeuralNetwork;
 
 },{"./lookup":3,"./train-stream":33,"./utilities/max":35,"./utilities/mse":36,"./utilities/randos":40,"./utilities/range":41,"./utilities/to-array":42,"./utilities/zeros":43,"thaw.js":100}],6:[function(require,module,exports){
 "use strict";function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _possibleConstructorReturn(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function _inherits(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(exports,"__esModule",{value:!0});var _createClass=function(){function e(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}return function(t,r,n){return r&&e(t.prototype,r),n&&e(t,n),t}}(),_matrix=require("./matrix"),_matrix2=_interopRequireDefault(_matrix),_randomMatrix=require("./matrix/random-matrix"),_randomMatrix2=_interopRequireDefault(_randomMatrix),_rnn=require("./rnn"),_rnn2=_interopRequireDefault(_rnn),GRU=function(e){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return _inherits(t,e),_createClass(t,[{key:"getModel",value:function(e,t){return{updateGateInputMatrix:new _randomMatrix2.default(e,t,.08),updateGateHiddenMatrix:new _randomMatrix2.default(e,e,.08),updateGateBias:new _matrix2.default(e,1),resetGateInputMatrix:new _randomMatrix2.default(e,t,.08),resetGateHiddenMatrix:new _randomMatrix2.default(e,e,.08),resetGateBias:new _matrix2.default(e,1),cellWriteInputMatrix:new _randomMatrix2.default(e,t,.08),cellWriteHiddenMatrix:new _randomMatrix2.default(e,e,.08),cellWriteBias:new _matrix2.default(e,1)}}},{key:"getEquation",value:function(e,t,r,n){var a=e.sigmoid.bind(e),i=e.add.bind(e),u=e.multiply.bind(e),o=e.multiplyElement.bind(e),l=e.tanh.bind(e),d=e.allOnes.bind(e),s=e.cloneNegative.bind(e),c=a(i(i(u(n.updateGateInputMatrix,t),u(n.updateGateHiddenMatrix,r)),n.updateGateBias)),f=a(i(i(u(n.resetGateInputMatrix,t),u(n.resetGateHiddenMatrix,r)),n.resetGateBias)),p=l(i(i(u(n.cellWriteInputMatrix,t),u(n.cellWriteHiddenMatrix,o(f,r))),n.cellWriteBias));return i(o(i(d(c.rows,c.columns),s(c)),p),o(r,c))}}]),t}(_rnn2.default);exports.default=GRU;
diff --git a/dist/neural-network.js b/dist/neural-network.js
index 1311d5927..abe00a1f3 100644
--- a/dist/neural-network.js
+++ b/dist/neural-network.js
@@ -162,23 +162,23 @@ var NeuralNetwork = function () {
       this.activation = activation ? activation : this.activation;
       switch (this.activation) {
         case 'sigmoid':
-          this.runInput = this.runInput || this.runInputSigmoid;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;
+          this.runInput = this.runInput || this._runInputSigmoid;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasSigmoid;
           break;
         case 'relu':
-          this.runInput = this.runInput || this.runInputRelu;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;
+          this.runInput = this.runInput || this._runInputRelu;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasRelu;
           break;
         case 'leaky-relu':
-          this.runInput = this.runInput || this.runInputLeakyRelu;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;
+          this.runInput = this.runInput || this._runInputLeakyRelu;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasLeakyRelu;
           break;
         case 'tanh':
-          this.runInput = this.runInput || this.runInputTanh;
-          this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;
+          this.runInput = this.runInput || this._runInputTanh;
+          this.calculateDeltas = this.calculateDeltas || this._calculateDeltasTanh;
           break;
         default:
-          throw new Error('unknown activation ' + this.activation);
+          throw new Error('unknown activation ' + this.activation + ', The activation should be one of [\'sigmoid\', \'relu\', \'leaky-relu\', \'tanh\']');
       }
     }
 
@@ -217,8 +217,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'runInputSigmoid',
-    value: function runInputSigmoid(input) {
+    key: '_runInputSigmoid',
+    value: function _runInputSigmoid(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -238,8 +238,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputRelu',
-    value: function runInputRelu(input) {
+    key: '_runInputRelu',
+    value: function _runInputRelu(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -259,8 +259,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputLeakyRelu',
-    value: function runInputLeakyRelu(input) {
+    key: '_runInputLeakyRelu',
+    value: function _runInputLeakyRelu(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -280,8 +280,8 @@ var NeuralNetwork = function () {
       return output;
     }
   }, {
-    key: 'runInputTanh',
-    value: function runInputTanh(input) {
+    key: '_runInputTanh',
+    value: function _runInputTanh(input) {
       this.outputs[0] = input; // set output state of input layer
 
       var output = null;
@@ -485,7 +485,7 @@ var NeuralNetwork = function () {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       this.updateTrainingOptions(options);
-      data = this.formatData(data);
+      data = this._formatData(data);
       var endTime = Date.now() + this.trainOpts.timeout;
 
       var status = {
@@ -519,7 +519,7 @@ var NeuralNetwork = function () {
 
       return new Promise(function (resolve, reject) {
         _this2.updateTrainingOptions(options);
-        data = _this2.formatData(data);
+        data = _this2._formatData(data);
         var endTime = Date.now() + _this2.trainOpts.timeout;
 
         var status = {
@@ -562,7 +562,7 @@ var NeuralNetwork = function () {
 
       // back propagate
       this.calculateDeltas(target);
-      this.adjustWeights();
+      this._adjustWeights();
 
       var error = (0, _mse2.default)(this.errors[this.outputLayer]);
       return error;
@@ -574,8 +574,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasSigmoid',
-    value: function calculateDeltasSigmoid(target) {
+    key: '_calculateDeltasSigmoid',
+    value: function _calculateDeltasSigmoid(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -601,8 +601,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasRelu',
-    value: function calculateDeltasRelu(target) {
+    key: '_calculateDeltasRelu',
+    value: function _calculateDeltasRelu(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -628,8 +628,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasLeakyRelu',
-    value: function calculateDeltasLeakyRelu(target) {
+    key: '_calculateDeltasLeakyRelu',
+    value: function _calculateDeltasLeakyRelu(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -655,8 +655,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'calculateDeltasTanh',
-    value: function calculateDeltasTanh(target) {
+    key: '_calculateDeltasTanh',
+    value: function _calculateDeltasTanh(target) {
       for (var layer = this.outputLayer; layer >= 0; layer--) {
         for (var node = 0; node < this.sizes[layer]; node++) {
           var output = this.outputs[layer][node];
@@ -682,8 +682,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'adjustWeights',
-    value: function adjustWeights() {
+    key: '_adjustWeights',
+    value: function _adjustWeights() {
       for (var layer = 1; layer <= this.outputLayer; layer++) {
         var incoming = this.outputs[layer - 1];
 
@@ -710,8 +710,8 @@ var NeuralNetwork = function () {
      */
 
   }, {
-    key: 'formatData',
-    value: function formatData(data) {
+    key: '_formatData',
+    value: function _formatData(data) {
       var _this3 = this;
 
       if (!Array.isArray(data)) {
@@ -764,7 +764,7 @@ var NeuralNetwork = function () {
     value: function test(data) {
       var _this4 = this;
 
-      data = this.formatData(data);
+      data = this._formatData(data);
 
       // for binary classification problems with one output node
       var isBinary = data[0].output.length === 1;
diff --git a/dist/neural-network.js.map b/dist/neural-network.js.map
index 3e616a77b..1b233c863 100644
--- a/dist/neural-network.js.map
+++ b/dist/neural-network.js.map
@@ -1 +1 @@
-{"version":3,"sources":["../src/neural-network.js"],"names":["NeuralNetwork","iterations","errorThresh","log","logPeriod","learningRate","momentum","callback","callbackPeriod","timeout","Infinity","binaryThresh","hiddenLayers","activation","options","Object","assign","constructor","defaults","hiddenSizes","trainOpts","updateTrainingOptions","trainDefaults","sizes","outputLayer","biases","weights","outputs","deltas","changes","errors","prototype","hasOwnProperty","runInput","calculateDeltas","Error","length","layer","size","Array","node","prevSize","setActivation","runInputSigmoid","calculateDeltasSigmoid","runInputRelu","calculateDeltasRelu","runInputLeakyRelu","calculateDeltasLeakyRelu","runInputTanh","calculateDeltasTanh","input","isRunnable","inputLookup","toArray","output","outputLookup","toHash","sum","k","Math","exp","tanh","data","push","max","floor","forEach","_initialize","opts","_setLogMethod","results","console","i","_trainPattern","status","error","_calculateTrainingError","formatData","endTime","Date","now","_verifyIsInitialized","_trainingTick","Promise","resolve","reject","items","thaw","delay","each","stop","done","tick","target","adjustWeights","incoming","delta","change","isArray","tmp","datum","Float32Array","buildLookup","map","value","array","isBinary","falsePos","falseNeg","truePos","trueNeg","misclasses","actual","expected","indexOf","misclass","stats","total","precision","recall","accuracy","layers","nodes","keys","j","bias","index","_getTrainOptsJSON","json","lookupFromHash","nodeHandle","layerNumber","nodeKey","result","w","join","toJSON","layersAsMath","key","Function","neuralNetwork","trainStream","checkFns","filter","c"],"mappings":"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","file":"neural-network.js","sourcesContent":["import lookup from './lookup';\nimport TrainStream from './train-stream';\nimport max from './utilities/max';\nimport mse from './utilities/mse';\nimport randos from './utilities/randos';\nimport range from './utilities/range';\nimport toArray from './utilities/to-array';\nimport zeros from './utilities/zeros';\nimport Thaw from 'thaw.js';\n\n/**\n * @param {object} options\n * @constructor\n */\nexport default class NeuralNetwork {\n  static get trainDefaults() {\n    return {\n      iterations: 20000,    // the maximum times to iterate the training data\n      errorThresh: 0.005,   // the acceptable error percentage from training data\n      log: false,           // true to use console.log, when a function is supplied it is used\n      logPeriod: 10,        // iterations between logging out\n      learningRate: 0.3,    // multiply's against the input and the delta then adds to momentum\n      momentum: 0.1,        // multiply's against the specified \"change\" then adds to learning rate for change\n      callback: null,       // a periodic call back that can be triggered while training\n      callbackPeriod: 10,   // the number of iterations through the training data between callback calls\n      timeout: Infinity     // the max number of milliseconds to train for\n    };\n  }\n\n  static get defaults() {\n    return {\n      binaryThresh: 0.5,     // ¯\\_(ツ)_/¯\n      hiddenLayers: [3],     // array of ints for the sizes of the hidden layers in the network\n      activation: 'sigmoid'  // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n    };\n  }\n\n  constructor(options = {}) {\n    Object.assign(this, this.constructor.defaults, options);\n    this.hiddenSizes = options.hiddenLayers;\n    this.trainOpts = {};\n    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));\n\n    this.sizes = null;\n    this.outputLayer = null;\n    this.biases = null; // weights for bias nodes\n    this.weights = null;\n    this.outputs = null;\n\n    // state for training\n    this.deltas = null;\n    this.changes = null; // for momentum\n    this.errors = null;\n\n    if (!this.constructor.prototype.hasOwnProperty('runInput')) {\n      this.runInput = null;\n    }\n    if (!this.constructor.prototype.hasOwnProperty('calculateDeltas')) {\n      this.calculateDeltas = null;\n    }\n  }\n\n  /**\n   *\n   * Expects this.sizes to have been set\n   */\n  _initialize() {\n    if (!this.sizes) throw new Error ('Sizes must be set before initializing')\n\n    this.outputLayer = this.sizes.length - 1;\n    this.biases = []; // weights for bias nodes\n    this.weights = [];\n    this.outputs = [];\n\n    // state for training\n    this.deltas = [];\n    this.changes = []; // for momentum\n    this.errors = [];\n\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      let size = this.sizes[layer];\n      this.deltas[layer] = zeros(size);\n      this.errors[layer] = zeros(size);\n      this.outputs[layer] = zeros(size);\n\n      if (layer > 0) {\n        this.biases[layer] = randos(size);\n        this.weights[layer] = new Array(size);\n        this.changes[layer] = new Array(size);\n\n        for (let node = 0; node < size; node++) {\n          let prevSize = this.sizes[layer - 1];\n          this.weights[layer][node] = randos(prevSize);\n          this.changes[layer][node] = zeros(prevSize);\n        }\n      }\n    }\n\n    this.setActivation();\n  }\n\n  /**\n   *\n   * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  setActivation(activation) {\n    this.activation = (activation) ? activation : this.activation;\n    switch (this.activation) {\n      case 'sigmoid':\n        this.runInput = this.runInput || this.runInputSigmoid;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;\n        break;\n      case 'relu':\n        this.runInput = this.runInput || this.runInputRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;\n        break;\n      case 'leaky-relu':\n        this.runInput = this.runInput || this.runInputLeakyRelu;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;\n        break;\n      case 'tanh':\n        this.runInput = this.runInput || this.runInputTanh;\n        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;\n        break;\n      default:\n        throw new Error('unknown activation ' + this.activation);\n    }\n  }\n\n  /**\n   *\n   * @returns boolean\n   */\n  get isRunnable(){\n    if(!this.runInput){\n      console.error('Activation function has not been initialized, did you run train()?');\n      return false;\n    }\n\n    const checkFns = [\n      'sizes',\n      'outputLayer',\n      'biases',\n      'weights',\n      'outputs',\n      'deltas',\n      'changes',\n      'errors',\n    ].filter(c => this[c] === null);\n\n    if(checkFns.length > 0){\n      console.error(`Some settings have not been initialized correctly, did you run train()? Found issues with: ${checkFns.join(', ')}`);\n      return false;\n    }\n    return true;\n  }\n\n\n  /**\n   *\n   * @param input\n   * @returns {*}\n   */\n  run(input) {\n    if (!this.isRunnable) return null;\n    if (this.inputLookup) {\n      input = lookup.toArray(this.inputLookup, input);\n    }\n\n    let output = [...this.runInput(input)];\n\n    if (this.outputLookup) {\n      output = lookup.toHash(this.outputLookup, output);\n    }\n    return output;\n  }\n\n  /**\n   * trains via sigmoid\n   * @param input\n   * @returns {*}\n   */\n  runInputSigmoid(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //sigmoid\n        this.outputs[layer][node] = 1 / (1 + Math.exp(-sum));\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputLeakyRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //leaky relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : 0.01 * sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  runInputTanh(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //tanh\n        this.outputs[layer][node] = Math.tanh(sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  /**\n   *\n   * @param data\n   * Verifies network sizes are initilaized\n   * If they are not it will initialize them based off the data set.\n   */\n  _verifyIsInitialized(data) {\n    if (this.sizes) return;\n\n    this.sizes = [];\n    this.sizes.push(data[0].input.length);\n    if (!this.hiddenSizes) {\n      this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));\n    } else {\n      this.hiddenSizes.forEach(size => {\n        this.sizes.push(size);\n      });\n    }\n    this.sizes.push(data[0].output.length)\n\n    this._initialize();\n  }\n\n  /**\n   *\n   * @param options\n   *    Supports all `trainDefaults` properties\n   *    also supports:\n   *       learningRate: (number),\n   *       momentum: (number),\n   *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  updateTrainingOptions(opts) {\n    if (opts.iterations) { this.trainOpts.iterations = opts.iterations; }\n    if (opts.errorThresh) { this.trainOpts.errorThresh = opts.errorThresh; }\n    if (opts.log) { this._setLogMethod(opts.log); }\n    if (opts.logPeriod) { this.trainOpts.logPeriod = opts.logPeriod; }\n    if (opts.learningRate) { this.trainOpts.learningRate = opts.learningRate; }\n    if (opts.momentum) { this.trainOpts.momentum = opts.momentum; }\n    if (opts.callback) { this.trainOpts.callback = opts.callback; }\n    if (opts.callbackPeriod) { this.trainOpts.callbackPeriod = opts.callbackPeriod; }\n    if (opts.timeout) { this.trainOpts.timeout = opts.timeout; }\n    if (opts.activation) { this.activation = opts.activation; }\n  }\n\n  /**\n   *\n   *  Gets JSON of trainOpts object\n   *    NOTE: Activation is stored directly on JSON object and not in the training options\n   */\n  _getTrainOptsJSON() {\n    let results = {}\n    if (this.trainOpts.iterations) { results.iterations = this.trainOpts.iterations; }\n    if (this.trainOpts.errorThresh) { results.errorThresh = this.trainOpts.errorThresh; }\n    if (this.trainOpts.logPeriod) { results.logPeriod = this.trainOpts.logPeriod; }\n    if (this.trainOpts.learningRate) { results.learningRate = this.trainOpts.learningRate; }\n    if (this.trainOpts.momentum) { results.momentum = this.trainOpts.momentum; }\n    if (this.trainOpts.callback) { results.callback = this.trainOpts.callback; }\n    if (this.trainOpts.callbackPeriod) { results.callbackPeriod = this.trainOpts.callbackPeriod; }\n    if (this.trainOpts.timeout) { results.timeout = this.trainOpts.timeout; }\n    if (this.trainOpts.log) { results.log = true; }\n    return results;\n  }\n\n  /**\n   *\n   * @param log\n   * if a method is passed in method is used\n   * if false passed in nothing is logged\n   * @returns error\n   */\n  _setLogMethod(log) {\n    if (typeof log === 'function'){\n      this.trainOpts.log = log;\n    } else if (log) {\n      this.trainOpts.log = console.log;\n    } else {\n      this.trainOpts.log = false;\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param learning Rate\n   * @returns error\n   */\n  _calculateTrainingError(data) {\n    let sum = 0;\n    for (let i = 0; i < data.length; ++i) {\n      sum += this._trainPattern(data[i].input, data[i].output);\n    }\n    return sum / data.length;\n  }\n\n  /**\n   *\n   * @param status { iterations: number, error: number}\n   * @param options\n   */\n  _trainingTick(data, status) {\n    status.iterations++;\n    status.error = this._calculateTrainingError(data);\n\n    if (this.trainOpts.log && (status.iterations % this.trainOpts.logPeriod === 0)) {\n      this.trainOpts.log(`iterations: ${status.iterations}, training error: ${status.error}`);\n    }\n\n    if (this.trainOpts.callback && (status.iterations % this.trainOpts.callbackPeriod === 0)) {\n      this.trainOpts.callback(Object.assign(status));\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @returns {{error: number, iterations: number}}\n   */\n  train(data, options = {}) {\n    this.updateTrainingOptions(options);\n    data = this.formatData(data);\n    const endTime = Date.now() + this.trainOpts.timeout;\n\n    const status = {\n      error: 1,\n      iterations: 0\n    };\n\n    this._verifyIsInitialized(data);\n\n    while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {\n      this._trainingTick(data, status);\n    }\n\n    return status;\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @param cb\n   * @returns {{error: number, iterations: number}}\n   */\n  trainAsync(data, options = {}) {\n    return new Promise((resolve, reject) => {\n      this.updateTrainingOptions(options);\n      data = this.formatData(data);\n      const endTime = Date.now() + this.trainOpts.timeout;\n\n      const status = {\n        error: 1,\n        iterations: 0\n      };\n\n      this._verifyIsInitialized(data);\n\n      const items = new Array(this.trainOpts.iterations);\n      const thaw  = new Thaw(items, {\n        delay: true,\n        each: () => {\n          this._trainingTick(data, status);\n          if (status.error < this.trainOpts.errorThresh || Date.now() > endTime) {\n            thaw.stop();\n          }\n        },\n        done: () => { resolve(status); }\n      });\n\n      thaw.tick();\n    });\n  }\n\n  /**\n   *\n   * @param input\n   * @param target\n   */\n  _trainPattern(input, target) {\n\n    // forward propagate\n    this.runInput(input);\n\n    // back propagate\n    this.calculateDeltas(target);\n    this.adjustWeights();\n\n    let error = mse(this.errors[this.outputLayer]);\n    return error;\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasSigmoid(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = error * output * (1 - output);\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasLeakyRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0.01 * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  calculateDeltasTanh(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = (1 - output * output) * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * Changes weights of networks\n   */\n  adjustWeights() {\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      let incoming = this.outputs[layer - 1];\n\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let delta = this.deltas[layer][node];\n\n        for (let k = 0; k < incoming.length; k++) {\n          let change = this.changes[layer][node][k];\n\n          change = (this.trainOpts.learningRate * delta * incoming[k])\n            + (this.trainOpts.momentum * change);\n\n          this.changes[layer][node][k] = change;\n          this.weights[layer][node][k] += change;\n        }\n        this.biases[layer][node] += this.trainOpts.learningRate * delta;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {*}\n   */\n  formatData(data) {\n    if (!Array.isArray(data)) { // turn stream datum into array\n      let tmp = [];\n      tmp.push(data);\n      data = tmp;\n    }\n    // turn sparse hash input into arrays with 0s as filler\n    let datum = data[0].input;\n    if (!Array.isArray(datum) && !(datum instanceof Float32Array)) {\n      if (!this.inputLookup) {\n        this.inputLookup = lookup.buildLookup(data.map(value => value['input']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.inputLookup, datum.input);\n        return Object.assign({}, datum, { input: array });\n      }, this);\n    }\n\n    if (!Array.isArray(data[0].output)) {\n      if (!this.outputLookup) {\n        this.outputLookup = lookup.buildLookup(data.map(value => value['output']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.outputLookup, datum.output);\n        return Object.assign({}, datum, { output: array });\n      }, this);\n    }\n    return data;\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {\n   *  {\n   *    error: number,\n   *    misclasses: Array\n   *  }\n   * }\n   */\n  test(data) {\n    data = this.formatData(data);\n\n    // for binary classification problems with one output node\n    let isBinary = data[0].output.length === 1;\n    let falsePos = 0;\n    let falseNeg = 0;\n    let truePos = 0;\n    let trueNeg = 0;\n\n    // for classification problems\n    let misclasses = [];\n\n    // run each pattern through the trained network and collect\n    // error and misclassification statistics\n    let sum = 0;\n    for (let i = 0; i < data.length; i++) {\n      let output = this.runInput(data[i].input);\n      let target = data[i].output;\n\n      let actual, expected;\n      if (isBinary) {\n        actual = output[0] > this.binaryThresh ? 1 : 0;\n        expected = target[0];\n      }\n      else {\n        actual = output.indexOf(max(output));\n        expected = target.indexOf(max(target));\n      }\n\n      if (actual !== expected) {\n        let misclass = data[i];\n        Object.assign(misclass, {\n          actual: actual,\n          expected: expected\n        });\n        misclasses.push(misclass);\n      }\n\n      if (isBinary) {\n        if (actual === 0 && expected === 0) {\n          trueNeg++;\n        } else if (actual === 1 && expected === 1) {\n          truePos++;\n        } else if (actual === 0 && expected === 1) {\n          falseNeg++;\n        } else if (actual === 1 && expected === 0) {\n          falsePos++;\n        }\n      }\n\n      let errors = output.map((value, i) => {\n        return target[i] - value;\n      });\n      sum += mse(errors);\n    }\n    let error = sum / data.length;\n\n    let stats = {\n      error: error,\n      misclasses: misclasses\n    };\n\n    if (isBinary) {\n      Object.assign(stats, {\n        trueNeg: trueNeg,\n        truePos: truePos,\n        falseNeg: falseNeg,\n        falsePos: falsePos,\n        total: data.length,\n        precision: truePos / (truePos + falsePos),\n        recall: truePos / (truePos + falseNeg),\n        accuracy: (trueNeg + truePos) / data.length\n      });\n    }\n    return stats;\n  }\n\n  /**\n   *\n   * @returns\n   *  {\n   *    layers: [\n   *      {\n   *        x: {},\n   *        y: {}\n   *      },\n   *      {\n   *        '0': {\n   *          bias: -0.98771313,\n   *          weights: {\n   *            x: 0.8374838,\n   *            y: 1.245858\n   *          },\n   *        '1': {\n   *          bias: 3.48192004,\n   *          weights: {\n   *            x: 1.7825821,\n   *            y: -2.67899\n   *          }\n   *        }\n   *      },\n   *      {\n   *        f: {\n   *          bias: 0.27205739,\n   *          weights: {\n   *            '0': 1.3161821,\n   *            '1': 2.00436\n   *          }\n   *        }\n   *      }\n   *    ]\n   *  }\n   */\n  toJSON() {\n    let layers = [];\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      layers[layer] = {};\n\n      let nodes;\n      // turn any internal arrays back into hashes for readable json\n      if (layer === 0 && this.inputLookup) {\n        nodes = Object.keys(this.inputLookup);\n      }\n      else if (layer === this.outputLayer && this.outputLookup) {\n        nodes = Object.keys(this.outputLookup);\n      }\n      else {\n        nodes = range(0, this.sizes[layer]);\n      }\n\n      for (let j = 0; j < nodes.length; j++) {\n        let node = nodes[j];\n        layers[layer][node] = {};\n\n        if (layer > 0) {\n          layers[layer][node].bias = this.biases[layer][j];\n          layers[layer][node].weights = {};\n          for (let k in layers[layer - 1]) {\n            let index = k;\n            if (layer === 1 && this.inputLookup) {\n              index = this.inputLookup[k];\n            }\n            layers[layer][node].weights[k] = this.weights[layer][j][index];\n          }\n        }\n      }\n    }\n    return {\n      sizes: this.sizes,\n      layers,\n      outputLookup:!!this.outputLookup,\n      inputLookup:!!this.inputLookup,\n      activation: this.activation,\n      trainOpts: this._getTrainOptsJSON()\n    };\n  }\n\n  /**\n   *\n   * @param json\n   * @returns {NeuralNetwork}\n   */\n  fromJSON (json) {\n    this.sizes = json.sizes\n    this._initialize();\n\n    for (let i = 0; i <= this.outputLayer; i++) {\n      let layer = json.layers[i];\n      if (i === 0 && (!layer[0] || json.inputLookup)) {\n        this.inputLookup = lookup.lookupFromHash(layer);\n      }\n      else if (i === this.outputLayer && (!layer[0] || json.outputLookup)) {\n        this.outputLookup = lookup.lookupFromHash(layer);\n      }\n      if (i > 0) {\n        const nodes = Object.keys(layer);\n        this.sizes[i] = nodes.length;\n        for (let j in nodes) {\n          const node = nodes[j];\n          this.biases[i][j] = layer[node].bias;\n          this.weights[i][j] = toArray(layer[node].weights);\n        }\n      }\n    }\n    this.updateTrainingOptions(json.trainOpts)\n    this.setActivation();\n    return this;\n  }\n\n  /**\n   *\n   * @returns {Function}\n   */\n  toFunction() {\n    const activation = this.activation;\n    function nodeHandle(layers, layerNumber, nodeKey) {\n      if (layerNumber === 0) {\n        return (typeof nodeKey === 'string'\n          ? `input['${nodeKey}']`\n          : `input[${nodeKey}]`);\n      }\n\n      const layer = layers[layerNumber];\n      const node = layer[nodeKey];\n      let result = [node.bias];\n      for (let w in node.weights) {\n        if (node.weights[w] < 0) {\n          result.push(`${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        } else {\n          result.push(`+${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        }\n      }\n\n      switch (activation) {\n        case 'sigmoid':\n          return `1/(1+1/Math.exp(${result.join('')}))`;\n        case 'relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : sum);`;\n        case 'leaky-relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : 0.01 * sum);`;\n        case 'tanh':\n          return `Math.tanh(${result.join('')});`;\n        default:\n          throw new Error('unknown activation type ' + activation);\n      }\n    }\n\n    const layers = this.toJSON().layers;\n    const layersAsMath = [];\n    let result;\n    for (let i in layers[layers.length - 1]) {\n      layersAsMath.push(nodeHandle(layers, layers.length - 1, i));\n    }\n    if (this.outputLookup) {\n      result = `{${\n        Object.keys(this.outputLookup)\n          .map((key, i) => `'${key}':${layersAsMath[i]}`)\n      }}`;\n    } else {\n      result = `[${layersAsMath.join(',')}]`;\n    }\n    return new Function('input', `return ${result}`);\n  }\n\n  /**\n   * This will create a TrainStream (WriteStream) for us to send the training data to.\n   * @param opts training options\n   * @returns {TrainStream|*}\n   */\n  createTrainStream(opts) {\n    opts = opts || {};\n    opts.neuralNetwork = this;\n    this.setActivation();\n    this.trainStream = new TrainStream(opts);\n    return this.trainStream;\n  }\n}"]}
\ No newline at end of file
+{"version":3,"sources":["../src/neural-network.js"],"names":["NeuralNetwork","iterations","errorThresh","log","logPeriod","learningRate","momentum","callback","callbackPeriod","timeout","Infinity","binaryThresh","hiddenLayers","activation","options","Object","assign","constructor","defaults","hiddenSizes","trainOpts","updateTrainingOptions","trainDefaults","sizes","outputLayer","biases","weights","outputs","deltas","changes","errors","prototype","hasOwnProperty","runInput","calculateDeltas","Error","length","layer","size","Array","node","prevSize","setActivation","_runInputSigmoid","_calculateDeltasSigmoid","_runInputRelu","_calculateDeltasRelu","_runInputLeakyRelu","_calculateDeltasLeakyRelu","_runInputTanh","_calculateDeltasTanh","input","isRunnable","inputLookup","toArray","output","outputLookup","toHash","sum","k","Math","exp","tanh","data","push","max","floor","forEach","_initialize","opts","_setLogMethod","results","console","i","_trainPattern","status","error","_calculateTrainingError","_formatData","endTime","Date","now","_verifyIsInitialized","_trainingTick","Promise","resolve","reject","items","thaw","delay","each","stop","done","tick","target","_adjustWeights","incoming","delta","change","isArray","tmp","datum","Float32Array","buildLookup","map","value","array","isBinary","falsePos","falseNeg","truePos","trueNeg","misclasses","actual","expected","indexOf","misclass","stats","total","precision","recall","accuracy","layers","nodes","keys","j","bias","index","_getTrainOptsJSON","json","lookupFromHash","nodeHandle","layerNumber","nodeKey","result","w","join","toJSON","layersAsMath","key","Function","neuralNetwork","trainStream","checkFns","filter","c"],"mappings":"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","file":"neural-network.js","sourcesContent":["import lookup from './lookup';\nimport TrainStream from './train-stream';\nimport max from './utilities/max';\nimport mse from './utilities/mse';\nimport randos from './utilities/randos';\nimport range from './utilities/range';\nimport toArray from './utilities/to-array';\nimport zeros from './utilities/zeros';\nimport Thaw from 'thaw.js';\n\n/**\n * @param {object} options\n * @constructor\n */\nexport default class NeuralNetwork {\n  static get trainDefaults() {\n    return {\n      iterations: 20000,    // the maximum times to iterate the training data\n      errorThresh: 0.005,   // the acceptable error percentage from training data\n      log: false,           // true to use console.log, when a function is supplied it is used\n      logPeriod: 10,        // iterations between logging out\n      learningRate: 0.3,    // multiply's against the input and the delta then adds to momentum\n      momentum: 0.1,        // multiply's against the specified \"change\" then adds to learning rate for change\n      callback: null,       // a periodic call back that can be triggered while training\n      callbackPeriod: 10,   // the number of iterations through the training data between callback calls\n      timeout: Infinity     // the max number of milliseconds to train for\n    };\n  }\n\n  static get defaults() {\n    return {\n      binaryThresh: 0.5,     // ¯\\_(ツ)_/¯\n      hiddenLayers: [3],     // array of ints for the sizes of the hidden layers in the network\n      activation: 'sigmoid'  // Supported activation types ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n    };\n  }\n\n  constructor(options = {}) {\n    Object.assign(this, this.constructor.defaults, options);\n    this.hiddenSizes = options.hiddenLayers;\n    this.trainOpts = {};\n    this.updateTrainingOptions(Object.assign({}, this.constructor.trainDefaults, options));\n\n    this.sizes = null;\n    this.outputLayer = null;\n    this.biases = null; // weights for bias nodes\n    this.weights = null;\n    this.outputs = null;\n\n    // state for training\n    this.deltas = null;\n    this.changes = null; // for momentum\n    this.errors = null;\n\n    if (!this.constructor.prototype.hasOwnProperty('runInput')) {\n      this.runInput = null;\n    }\n    if (!this.constructor.prototype.hasOwnProperty('calculateDeltas')) {\n      this.calculateDeltas = null;\n    }\n  }\n\n  /**\n   *\n   * Expects this.sizes to have been set\n   */\n  _initialize() {\n    if (!this.sizes) throw new Error ('Sizes must be set before initializing')\n\n    this.outputLayer = this.sizes.length - 1;\n    this.biases = []; // weights for bias nodes\n    this.weights = [];\n    this.outputs = [];\n\n    // state for training\n    this.deltas = [];\n    this.changes = []; // for momentum\n    this.errors = [];\n\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      let size = this.sizes[layer];\n      this.deltas[layer] = zeros(size);\n      this.errors[layer] = zeros(size);\n      this.outputs[layer] = zeros(size);\n\n      if (layer > 0) {\n        this.biases[layer] = randos(size);\n        this.weights[layer] = new Array(size);\n        this.changes[layer] = new Array(size);\n\n        for (let node = 0; node < size; node++) {\n          let prevSize = this.sizes[layer - 1];\n          this.weights[layer][node] = randos(prevSize);\n          this.changes[layer][node] = zeros(prevSize);\n        }\n      }\n    }\n\n    this.setActivation();\n  }\n\n  /**\n   *\n   * @param supported input: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  setActivation(activation) {\n    this.activation = (activation) ? activation : this.activation;\n    switch (this.activation) {\n      case 'sigmoid':\n        this.runInput = this.runInput || this._runInputSigmoid;\n        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasSigmoid;\n        break;\n      case 'relu':\n        this.runInput = this.runInput || this._runInputRelu;\n        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasRelu;\n        break;\n      case 'leaky-relu':\n        this.runInput = this.runInput || this._runInputLeakyRelu;\n        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasLeakyRelu;\n        break;\n      case 'tanh':\n        this.runInput = this.runInput || this._runInputTanh;\n        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasTanh;\n        break;\n      default:\n        throw new Error('unknown activation ' + this.activation + ', The activation should be one of [\\'sigmoid\\', \\'relu\\', \\'leaky-relu\\', \\'tanh\\']');\n    }\n  }\n\n  /**\n   *\n   * @returns boolean\n   */\n  get isRunnable(){\n    if(!this.runInput){\n      console.error('Activation function has not been initialized, did you run train()?');\n      return false;\n    }\n\n    const checkFns = [\n      'sizes',\n      'outputLayer',\n      'biases',\n      'weights',\n      'outputs',\n      'deltas',\n      'changes',\n      'errors',\n    ].filter(c => this[c] === null);\n\n    if(checkFns.length > 0){\n      console.error(`Some settings have not been initialized correctly, did you run train()? Found issues with: ${checkFns.join(', ')}`);\n      return false;\n    }\n    return true;\n  }\n\n\n  /**\n   *\n   * @param input\n   * @returns {*}\n   */\n  run(input) {\n    if (!this.isRunnable) return null;\n    if (this.inputLookup) {\n      input = lookup.toArray(this.inputLookup, input);\n    }\n\n    let output = [...this.runInput(input)];\n\n    if (this.outputLookup) {\n      output = lookup.toHash(this.outputLookup, output);\n    }\n    return output;\n  }\n\n  /**\n   * trains via sigmoid\n   * @param input\n   * @returns {*}\n   */\n  _runInputSigmoid(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //sigmoid\n        this.outputs[layer][node] = 1 / (1 + Math.exp(-sum));\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  _runInputRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  _runInputLeakyRelu(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //leaky relu\n        this.outputs[layer][node] = (sum < 0 ? 0 : 0.01 * sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  _runInputTanh(input) {\n    this.outputs[0] = input;  // set output state of input layer\n\n    let output = null;\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let weights = this.weights[layer][node];\n\n        let sum = this.biases[layer][node];\n        for (let k = 0; k < weights.length; k++) {\n          sum += weights[k] * input[k];\n        }\n        //tanh\n        this.outputs[layer][node] = Math.tanh(sum);\n      }\n      output = input = this.outputs[layer];\n    }\n    return output;\n  }\n\n  /**\n   *\n   * @param data\n   * Verifies network sizes are initilaized\n   * If they are not it will initialize them based off the data set.\n   */\n  _verifyIsInitialized(data) {\n    if (this.sizes) return;\n\n    this.sizes = [];\n    this.sizes.push(data[0].input.length);\n    if (!this.hiddenSizes) {\n      this.sizes.push(Math.max(3, Math.floor(data[0].input.length / 2)));\n    } else {\n      this.hiddenSizes.forEach(size => {\n        this.sizes.push(size);\n      });\n    }\n    this.sizes.push(data[0].output.length)\n\n    this._initialize();\n  }\n\n  /**\n   *\n   * @param options\n   *    Supports all `trainDefaults` properties\n   *    also supports:\n   *       learningRate: (number),\n   *       momentum: (number),\n   *       activation: ['sigmoid', 'relu', 'leaky-relu', 'tanh']\n   */\n  updateTrainingOptions(opts) {\n    if (opts.iterations) { this.trainOpts.iterations = opts.iterations; }\n    if (opts.errorThresh) { this.trainOpts.errorThresh = opts.errorThresh; }\n    if (opts.log) { this._setLogMethod(opts.log); }\n    if (opts.logPeriod) { this.trainOpts.logPeriod = opts.logPeriod; }\n    if (opts.learningRate) { this.trainOpts.learningRate = opts.learningRate; }\n    if (opts.momentum) { this.trainOpts.momentum = opts.momentum; }\n    if (opts.callback) { this.trainOpts.callback = opts.callback; }\n    if (opts.callbackPeriod) { this.trainOpts.callbackPeriod = opts.callbackPeriod; }\n    if (opts.timeout) { this.trainOpts.timeout = opts.timeout; }\n    if (opts.activation) { this.activation = opts.activation; }\n  }\n\n  /**\n   *\n   *  Gets JSON of trainOpts object\n   *    NOTE: Activation is stored directly on JSON object and not in the training options\n   */\n  _getTrainOptsJSON() {\n    let results = {}\n    if (this.trainOpts.iterations) { results.iterations = this.trainOpts.iterations; }\n    if (this.trainOpts.errorThresh) { results.errorThresh = this.trainOpts.errorThresh; }\n    if (this.trainOpts.logPeriod) { results.logPeriod = this.trainOpts.logPeriod; }\n    if (this.trainOpts.learningRate) { results.learningRate = this.trainOpts.learningRate; }\n    if (this.trainOpts.momentum) { results.momentum = this.trainOpts.momentum; }\n    if (this.trainOpts.callback) { results.callback = this.trainOpts.callback; }\n    if (this.trainOpts.callbackPeriod) { results.callbackPeriod = this.trainOpts.callbackPeriod; }\n    if (this.trainOpts.timeout) { results.timeout = this.trainOpts.timeout; }\n    if (this.trainOpts.log) { results.log = true; }\n    return results;\n  }\n\n  /**\n   *\n   * @param log\n   * if a method is passed in method is used\n   * if false passed in nothing is logged\n   * @returns error\n   */\n  _setLogMethod(log) {\n    if (typeof log === 'function'){\n      this.trainOpts.log = log;\n    } else if (log) {\n      this.trainOpts.log = console.log;\n    } else {\n      this.trainOpts.log = false;\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param learning Rate\n   * @returns error\n   */\n  _calculateTrainingError(data) {\n    let sum = 0;\n    for (let i = 0; i < data.length; ++i) {\n      sum += this._trainPattern(data[i].input, data[i].output);\n    }\n    return sum / data.length;\n  }\n\n  /**\n   *\n   * @param status { iterations: number, error: number}\n   * @param options\n   */\n  _trainingTick(data, status) {\n    status.iterations++;\n    status.error = this._calculateTrainingError(data);\n\n    if (this.trainOpts.log && (status.iterations % this.trainOpts.logPeriod === 0)) {\n      this.trainOpts.log(`iterations: ${status.iterations}, training error: ${status.error}`);\n    }\n\n    if (this.trainOpts.callback && (status.iterations % this.trainOpts.callbackPeriod === 0)) {\n      this.trainOpts.callback(Object.assign(status));\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @returns {{error: number, iterations: number}}\n   */\n  train(data, options = {}) {\n    this.updateTrainingOptions(options);\n    data = this._formatData(data);\n    const endTime = Date.now() + this.trainOpts.timeout;\n\n    const status = {\n      error: 1,\n      iterations: 0\n    };\n\n    this._verifyIsInitialized(data);\n\n    while (status.iterations < this.trainOpts.iterations && status.error > this.trainOpts.errorThresh && Date.now() < endTime) {\n      this._trainingTick(data, status);\n    }\n\n    return status;\n  }\n\n  /**\n   *\n   * @param data\n   * @param options\n   * @param cb\n   * @returns {{error: number, iterations: number}}\n   */\n  trainAsync(data, options = {}) {\n    return new Promise((resolve, reject) => {\n      this.updateTrainingOptions(options);\n      data = this._formatData(data);\n      const endTime = Date.now() + this.trainOpts.timeout;\n\n      const status = {\n        error: 1,\n        iterations: 0\n      };\n\n      this._verifyIsInitialized(data);\n\n      const items = new Array(this.trainOpts.iterations);\n      const thaw  = new Thaw(items, {\n        delay: true,\n        each: () => {\n          this._trainingTick(data, status);\n          if (status.error < this.trainOpts.errorThresh || Date.now() > endTime) {\n            thaw.stop();\n          }\n        },\n        done: () => { resolve(status); }\n      });\n\n      thaw.tick();\n    });\n  }\n\n  /**\n   *\n   * @param input\n   * @param target\n   */\n  _trainPattern(input, target) {\n\n    // forward propagate\n    this.runInput(input);\n\n    // back propagate\n    this.calculateDeltas(target);\n    this._adjustWeights();\n\n    let error = mse(this.errors[this.outputLayer]);\n    return error;\n  }\n\n  /**\n   *\n   * @param target\n   */\n  _calculateDeltasSigmoid(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = error * output * (1 - output);\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  _calculateDeltasRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  _calculateDeltasLeakyRelu(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = output > 0 ? error : 0.01 * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param target\n   */\n  _calculateDeltasTanh(target) {\n    for (let layer = this.outputLayer; layer >= 0; layer--) {\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let output = this.outputs[layer][node];\n\n        let error = 0;\n        if (layer === this.outputLayer) {\n          error = target[node] - output;\n        }\n        else {\n          let deltas = this.deltas[layer + 1];\n          for (let k = 0; k < deltas.length; k++) {\n            error += deltas[k] * this.weights[layer + 1][k][node];\n          }\n        }\n        this.errors[layer][node] = error;\n        this.deltas[layer][node] = (1 - output * output) * error;\n      }\n    }\n  }\n\n  /**\n   *\n   * Changes weights of networks\n   */\n  _adjustWeights() {\n    for (let layer = 1; layer <= this.outputLayer; layer++) {\n      let incoming = this.outputs[layer - 1];\n\n      for (let node = 0; node < this.sizes[layer]; node++) {\n        let delta = this.deltas[layer][node];\n\n        for (let k = 0; k < incoming.length; k++) {\n          let change = this.changes[layer][node][k];\n\n          change = (this.trainOpts.learningRate * delta * incoming[k])\n            + (this.trainOpts.momentum * change);\n\n          this.changes[layer][node][k] = change;\n          this.weights[layer][node][k] += change;\n        }\n        this.biases[layer][node] += this.trainOpts.learningRate * delta;\n      }\n    }\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {*}\n   */\n  _formatData(data) {\n    if (!Array.isArray(data)) { // turn stream datum into array\n      let tmp = [];\n      tmp.push(data);\n      data = tmp;\n    }\n    // turn sparse hash input into arrays with 0s as filler\n    let datum = data[0].input;\n    if (!Array.isArray(datum) && !(datum instanceof Float32Array)) {\n      if (!this.inputLookup) {\n        this.inputLookup = lookup.buildLookup(data.map(value => value['input']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.inputLookup, datum.input);\n        return Object.assign({}, datum, { input: array });\n      }, this);\n    }\n\n    if (!Array.isArray(data[0].output)) {\n      if (!this.outputLookup) {\n        this.outputLookup = lookup.buildLookup(data.map(value => value['output']));\n      }\n      data = data.map(datum => {\n        let array = lookup.toArray(this.outputLookup, datum.output);\n        return Object.assign({}, datum, { output: array });\n      }, this);\n    }\n    return data;\n  }\n\n  /**\n   *\n   * @param data\n   * @returns {\n   *  {\n   *    error: number,\n   *    misclasses: Array\n   *  }\n   * }\n   */\n  test(data) {\n    data = this._formatData(data);\n\n    // for binary classification problems with one output node\n    let isBinary = data[0].output.length === 1;\n    let falsePos = 0;\n    let falseNeg = 0;\n    let truePos = 0;\n    let trueNeg = 0;\n\n    // for classification problems\n    let misclasses = [];\n\n    // run each pattern through the trained network and collect\n    // error and misclassification statistics\n    let sum = 0;\n    for (let i = 0; i < data.length; i++) {\n      let output = this.runInput(data[i].input);\n      let target = data[i].output;\n\n      let actual, expected;\n      if (isBinary) {\n        actual = output[0] > this.binaryThresh ? 1 : 0;\n        expected = target[0];\n      }\n      else {\n        actual = output.indexOf(max(output));\n        expected = target.indexOf(max(target));\n      }\n\n      if (actual !== expected) {\n        let misclass = data[i];\n        Object.assign(misclass, {\n          actual: actual,\n          expected: expected\n        });\n        misclasses.push(misclass);\n      }\n\n      if (isBinary) {\n        if (actual === 0 && expected === 0) {\n          trueNeg++;\n        } else if (actual === 1 && expected === 1) {\n          truePos++;\n        } else if (actual === 0 && expected === 1) {\n          falseNeg++;\n        } else if (actual === 1 && expected === 0) {\n          falsePos++;\n        }\n      }\n\n      let errors = output.map((value, i) => {\n        return target[i] - value;\n      });\n      sum += mse(errors);\n    }\n    let error = sum / data.length;\n\n    let stats = {\n      error: error,\n      misclasses: misclasses\n    };\n\n    if (isBinary) {\n      Object.assign(stats, {\n        trueNeg: trueNeg,\n        truePos: truePos,\n        falseNeg: falseNeg,\n        falsePos: falsePos,\n        total: data.length,\n        precision: truePos / (truePos + falsePos),\n        recall: truePos / (truePos + falseNeg),\n        accuracy: (trueNeg + truePos) / data.length\n      });\n    }\n    return stats;\n  }\n\n  /**\n   *\n   * @returns\n   *  {\n   *    layers: [\n   *      {\n   *        x: {},\n   *        y: {}\n   *      },\n   *      {\n   *        '0': {\n   *          bias: -0.98771313,\n   *          weights: {\n   *            x: 0.8374838,\n   *            y: 1.245858\n   *          },\n   *        '1': {\n   *          bias: 3.48192004,\n   *          weights: {\n   *            x: 1.7825821,\n   *            y: -2.67899\n   *          }\n   *        }\n   *      },\n   *      {\n   *        f: {\n   *          bias: 0.27205739,\n   *          weights: {\n   *            '0': 1.3161821,\n   *            '1': 2.00436\n   *          }\n   *        }\n   *      }\n   *    ]\n   *  }\n   */\n  toJSON() {\n    let layers = [];\n    for (let layer = 0; layer <= this.outputLayer; layer++) {\n      layers[layer] = {};\n\n      let nodes;\n      // turn any internal arrays back into hashes for readable json\n      if (layer === 0 && this.inputLookup) {\n        nodes = Object.keys(this.inputLookup);\n      }\n      else if (layer === this.outputLayer && this.outputLookup) {\n        nodes = Object.keys(this.outputLookup);\n      }\n      else {\n        nodes = range(0, this.sizes[layer]);\n      }\n\n      for (let j = 0; j < nodes.length; j++) {\n        let node = nodes[j];\n        layers[layer][node] = {};\n\n        if (layer > 0) {\n          layers[layer][node].bias = this.biases[layer][j];\n          layers[layer][node].weights = {};\n          for (let k in layers[layer - 1]) {\n            let index = k;\n            if (layer === 1 && this.inputLookup) {\n              index = this.inputLookup[k];\n            }\n            layers[layer][node].weights[k] = this.weights[layer][j][index];\n          }\n        }\n      }\n    }\n    return {\n      sizes: this.sizes,\n      layers,\n      outputLookup:!!this.outputLookup,\n      inputLookup:!!this.inputLookup,\n      activation: this.activation,\n      trainOpts: this._getTrainOptsJSON()\n    };\n  }\n\n  /**\n   *\n   * @param json\n   * @returns {NeuralNetwork}\n   */\n  fromJSON (json) {\n    this.sizes = json.sizes\n    this._initialize();\n\n    for (let i = 0; i <= this.outputLayer; i++) {\n      let layer = json.layers[i];\n      if (i === 0 && (!layer[0] || json.inputLookup)) {\n        this.inputLookup = lookup.lookupFromHash(layer);\n      }\n      else if (i === this.outputLayer && (!layer[0] || json.outputLookup)) {\n        this.outputLookup = lookup.lookupFromHash(layer);\n      }\n      if (i > 0) {\n        const nodes = Object.keys(layer);\n        this.sizes[i] = nodes.length;\n        for (let j in nodes) {\n          const node = nodes[j];\n          this.biases[i][j] = layer[node].bias;\n          this.weights[i][j] = toArray(layer[node].weights);\n        }\n      }\n    }\n    this.updateTrainingOptions(json.trainOpts)\n    this.setActivation();\n    return this;\n  }\n\n  /**\n   *\n   * @returns {Function}\n   */\n  toFunction() {\n    const activation = this.activation;\n    function nodeHandle(layers, layerNumber, nodeKey) {\n      if (layerNumber === 0) {\n        return (typeof nodeKey === 'string'\n          ? `input['${nodeKey}']`\n          : `input[${nodeKey}]`);\n      }\n\n      const layer = layers[layerNumber];\n      const node = layer[nodeKey];\n      let result = [node.bias];\n      for (let w in node.weights) {\n        if (node.weights[w] < 0) {\n          result.push(`${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        } else {\n          result.push(`+${node.weights[w]}*(${nodeHandle(layers, layerNumber - 1, w)})`);\n        }\n      }\n\n      switch (activation) {\n        case 'sigmoid':\n          return `1/(1+1/Math.exp(${result.join('')}))`;\n        case 'relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : sum);`;\n        case 'leaky-relu':\n          return `var sum = ${result.join('')};(sum < 0 ? 0 : 0.01 * sum);`;\n        case 'tanh':\n          return `Math.tanh(${result.join('')});`;\n        default:\n          throw new Error('unknown activation type ' + activation);\n      }\n    }\n\n    const layers = this.toJSON().layers;\n    const layersAsMath = [];\n    let result;\n    for (let i in layers[layers.length - 1]) {\n      layersAsMath.push(nodeHandle(layers, layers.length - 1, i));\n    }\n    if (this.outputLookup) {\n      result = `{${\n        Object.keys(this.outputLookup)\n          .map((key, i) => `'${key}':${layersAsMath[i]}`)\n      }}`;\n    } else {\n      result = `[${layersAsMath.join(',')}]`;\n    }\n    return new Function('input', `return ${result}`);\n  }\n\n  /**\n   * This will create a TrainStream (WriteStream) for us to send the training data to.\n   * @param opts training options\n   * @returns {TrainStream|*}\n   */\n  createTrainStream(opts) {\n    opts = opts || {};\n    opts.neuralNetwork = this;\n    this.setActivation();\n    this.trainStream = new TrainStream(opts);\n    return this.trainStream;\n  }\n}"]}
\ No newline at end of file
diff --git a/src/neural-network.js b/src/neural-network.js
index e348d36de..4e048eb7b 100644
--- a/src/neural-network.js
+++ b/src/neural-network.js
@@ -107,23 +107,23 @@ export default class NeuralNetwork {
     this.activation = (activation) ? activation : this.activation;
     switch (this.activation) {
       case 'sigmoid':
-        this.runInput = this.runInput || this.runInputSigmoid;
-        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasSigmoid;
+        this.runInput = this.runInput || this._runInputSigmoid;
+        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasSigmoid;
         break;
       case 'relu':
-        this.runInput = this.runInput || this.runInputRelu;
-        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasRelu;
+        this.runInput = this.runInput || this._runInputRelu;
+        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasRelu;
         break;
       case 'leaky-relu':
-        this.runInput = this.runInput || this.runInputLeakyRelu;
-        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasLeakyRelu;
+        this.runInput = this.runInput || this._runInputLeakyRelu;
+        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasLeakyRelu;
         break;
       case 'tanh':
-        this.runInput = this.runInput || this.runInputTanh;
-        this.calculateDeltas = this.calculateDeltas || this.calculateDeltasTanh;
+        this.runInput = this.runInput || this._runInputTanh;
+        this.calculateDeltas = this.calculateDeltas || this._calculateDeltasTanh;
         break;
       default:
-        throw new Error('unknown activation ' + this.activation);
+        throw new Error('unknown activation ' + this.activation + ', The activation should be one of [\'sigmoid\', \'relu\', \'leaky-relu\', \'tanh\']');
     }
   }
 
@@ -180,7 +180,7 @@ export default class NeuralNetwork {
    * @param input
    * @returns {*}
    */
-  runInputSigmoid(input) {
+  _runInputSigmoid(input) {
     this.outputs[0] = input;  // set output state of input layer
 
     let output = null;
@@ -200,7 +200,7 @@ export default class NeuralNetwork {
     return output;
   }
 
-  runInputRelu(input) {
+  _runInputRelu(input) {
     this.outputs[0] = input;  // set output state of input layer
 
     let output = null;
@@ -220,7 +220,7 @@ export default class NeuralNetwork {
     return output;
   }
 
-  runInputLeakyRelu(input) {
+  _runInputLeakyRelu(input) {
     this.outputs[0] = input;  // set output state of input layer
 
     let output = null;
@@ -240,7 +240,7 @@ export default class NeuralNetwork {
     return output;
   }
 
-  runInputTanh(input) {
+  _runInputTanh(input) {
     this.outputs[0] = input;  // set output state of input layer
 
     let output = null;
@@ -381,7 +381,7 @@ export default class NeuralNetwork {
    */
   train(data, options = {}) {
     this.updateTrainingOptions(options);
-    data = this.formatData(data);
+    data = this._formatData(data);
     const endTime = Date.now() + this.trainOpts.timeout;
 
     const status = {
@@ -408,7 +408,7 @@ export default class NeuralNetwork {
   trainAsync(data, options = {}) {
     return new Promise((resolve, reject) => {
       this.updateTrainingOptions(options);
-      data = this.formatData(data);
+      data = this._formatData(data);
       const endTime = Date.now() + this.trainOpts.timeout;
 
       const status = {
@@ -446,7 +446,7 @@ export default class NeuralNetwork {
 
     // back propagate
     this.calculateDeltas(target);
-    this.adjustWeights();
+    this._adjustWeights();
 
     let error = mse(this.errors[this.outputLayer]);
     return error;
@@ -456,7 +456,7 @@ export default class NeuralNetwork {
    *
    * @param target
    */
-  calculateDeltasSigmoid(target) {
+  _calculateDeltasSigmoid(target) {
     for (let layer = this.outputLayer; layer >= 0; layer--) {
       for (let node = 0; node < this.sizes[layer]; node++) {
         let output = this.outputs[layer][node];
@@ -481,7 +481,7 @@ export default class NeuralNetwork {
    *
    * @param target
    */
-  calculateDeltasRelu(target) {
+  _calculateDeltasRelu(target) {
     for (let layer = this.outputLayer; layer >= 0; layer--) {
       for (let node = 0; node < this.sizes[layer]; node++) {
         let output = this.outputs[layer][node];
@@ -506,7 +506,7 @@ export default class NeuralNetwork {
    *
    * @param target
    */
-  calculateDeltasLeakyRelu(target) {
+  _calculateDeltasLeakyRelu(target) {
     for (let layer = this.outputLayer; layer >= 0; layer--) {
       for (let node = 0; node < this.sizes[layer]; node++) {
         let output = this.outputs[layer][node];
@@ -531,7 +531,7 @@ export default class NeuralNetwork {
    *
    * @param target
    */
-  calculateDeltasTanh(target) {
+  _calculateDeltasTanh(target) {
     for (let layer = this.outputLayer; layer >= 0; layer--) {
       for (let node = 0; node < this.sizes[layer]; node++) {
         let output = this.outputs[layer][node];
@@ -556,7 +556,7 @@ export default class NeuralNetwork {
    *
    * Changes weights of networks
    */
-  adjustWeights() {
+  _adjustWeights() {
     for (let layer = 1; layer <= this.outputLayer; layer++) {
       let incoming = this.outputs[layer - 1];
 
@@ -582,7 +582,7 @@ export default class NeuralNetwork {
    * @param data
    * @returns {*}
    */
-  formatData(data) {
+  _formatData(data) {
     if (!Array.isArray(data)) { // turn stream datum into array
       let tmp = [];
       tmp.push(data);
@@ -623,7 +623,7 @@ export default class NeuralNetwork {
    * }
    */
   test(data) {
-    data = this.formatData(data);
+    data = this._formatData(data);
 
     // for binary classification problems with one output node
     let isBinary = data[0].output.length === 1;
diff --git a/test/base/json.js b/test/base/json.js
index 2a274af66..af70ccdb7 100644
--- a/test/base/json.js
+++ b/test/base/json.js
@@ -1,28 +1,19 @@
 import assert from 'assert';
 import NeuralNetwork from './../../src/neural-network';
 
-let jsonNetwork = { sizes: [ 3, 3, 2 ],
-  layers: 
-   [ { r: {}, g: {}, b: {} },
-     { '0': [Object], '1': [Object], '2': [Object] },
-     { black: [Object], white: [Object] } ],
-  outputLookup: true,
-  inputLookup: true,
-  activation: 'relu',
-  trainOpts: {
-    iterations: 200,
-    errorThresh: 0.025,
-    logPeriod: 6,
-    learningRate: 0.4,
-    momentum: 0.2,
-    callbackPeriod: 3,
-    timeout: 500
-  }
-};
-
 describe('JSON', () => {
   const originalNet = new NeuralNetwork();
 
+  let trainingOpts = {
+    iterations: 200,
+    errorThresh: 0.05,
+    log: () => {},
+    logPeriod: 3,
+    learningRate: 0.03,
+    momentum: 0.01,
+    callbackPeriod: 5,
+    timeout: 3000 
+  }
   originalNet.train([
     {
       input: {'0': Math.random(), b: Math.random()},
@@ -31,7 +22,9 @@ describe('JSON', () => {
       input: {'0': Math.random(), b: Math.random()},
       output: {c: Math.random(), '0': Math.random()}
     }
-  ]);
+  ], trainingOpts);
+
+  trainingOpts.log = true;
 
   const serialized = originalNet.toJSON();
   const serializedNet = new NeuralNetwork().fromJSON(serialized);
@@ -75,6 +68,45 @@ describe('JSON', () => {
         assert.equal(serialized.activation, originalNet.activation);
       });
     });
+
+    describe('.trainOpts', () => {
+      it('training options iterations', () => {
+        assert.equal(trainingOpts.iterations, serialized.trainOpts.iterations, `trainingOpts.are: ${trainingOpts.iterations} serialized should be the same but are: ${serialized.trainOpts.iterations}`);
+      });
+
+      it('training options errorThresh', () => {
+        assert.equal(trainingOpts.errorThresh, serialized.trainOpts.errorThresh, `trainingOpts.are: ${trainingOpts.errorThresh} serialized should be the same but are: ${serialized.trainOpts.errorThresh}`);
+      });
+
+      it('training options log', () => {
+        assert.equal(trainingOpts.log, serialized.trainOpts.log, `log are: ${trainingOpts.log} serialized should be the same but are: ${serialized.trainOpts.log}`);
+      });
+
+      it('training options logPeriod', () => {
+        assert.equal(trainingOpts.logPeriod, serialized.trainOpts.logPeriod, `trainingOpts.are: ${trainingOpts.logPeriod} serialized should be the same but are: ${serialized.trainOpts.logPeriod}`);
+      });
+
+      it('training options learningRate', () => {
+        assert.equal(trainingOpts.learningRate, serialized.trainOpts.learningRate, `trainingOpts.are: ${trainingOpts.learningRate} serialized should be the same but are: ${serialized.trainOpts.learningRate}`);
+      });
+
+      it('training options momentum', () => {
+        assert.equal(trainingOpts.momentum, serialized.trainOpts.momentum, `trainingOpts.are: ${trainingOpts.momentum} serialized should be the same but are: ${serialized.trainOpts.momentum}`);
+      });
+
+      it('training options callback', () => {
+        assert.equal(trainingOpts.callback, serialized.trainOpts.callback, `trainingOpts.are: ${trainingOpts.callback} serialized should be the same but are: ${serialized.trainOpts.callback}`);
+      });
+
+      it('training options callbackPeriod', () => {
+        assert.equal(trainingOpts.callbackPeriod, serialized.trainOpts.callbackPeriod, `trainingOpts.are: ${trainingOpts.callbackPeriod} serialized should be the same but are: ${serialized.trainOpts.callbackPeriod}`);
+      });
+
+      it('training options timeout', () => {
+        assert.equal(trainingOpts.timeout, serialized.trainOpts.timeout, `trainingOpts.are: ${trainingOpts.timeout} serialized should be the same but are: ${serialized.trainOpts.timeout}`);
+      });
+    });
+
   });
 
   describe('.fromJSON()', () => {
@@ -102,6 +134,45 @@ describe('JSON', () => {
           assert.equal(serializedNet.activation, serialized.activation);
         });
       });
+
+      describe('.trainOpts', () => {
+        it('training options iterations', () => {
+          assert.equal(trainingOpts.iterations, serializedNet.trainOpts.iterations, `trainingOpts.are: ${trainingOpts.iterations} serializedNet should be the same but are: ${serializedNet.trainOpts.iterations}`);
+        });
+  
+        it('training options errorThresh', () => {
+          assert.equal(trainingOpts.errorThresh, serializedNet.trainOpts.errorThresh, `trainingOpts.are: ${trainingOpts.errorThresh} serializedNet should be the same but are: ${serializedNet.trainOpts.errorThresh}`);
+        });
+  
+        it('training options log', () => {
+          // Should have inflated to console.log
+          assert.equal(console.log, serializedNet.trainOpts.log, `log are: ${trainingOpts.log} serializedNet should be the same but are: ${serializedNet.trainOpts.log}`);
+        });
+  
+        it('training options logPeriod', () => {
+          assert.equal(trainingOpts.logPeriod, serializedNet.trainOpts.logPeriod, `trainingOpts.are: ${trainingOpts.logPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.logPeriod}`);
+        });
+  
+        it('training options learningRate', () => {
+          assert.equal(trainingOpts.learningRate, serializedNet.trainOpts.learningRate, `trainingOpts.are: ${trainingOpts.learningRate} serializedNet should be the same but are: ${serializedNet.trainOpts.learningRate}`);
+        });
+  
+        it('training options momentum', () => {
+          assert.equal(trainingOpts.momentum, serializedNet.trainOpts.momentum, `trainingOpts.are: ${trainingOpts.momentum} serializedNet should be the same but are: ${serializedNet.trainOpts.momentum}`);
+        });
+  
+        it('training options callback', () => {
+          assert.equal(trainingOpts.callback, serializedNet.trainOpts.callback, `trainingOpts.are: ${trainingOpts.callback} serializedNet should be the same but are: ${serializedNet.trainOpts.callback}`);
+        });
+  
+        it('training options callbackPeriod', () => {
+          assert.equal(trainingOpts.callbackPeriod, serializedNet.trainOpts.callbackPeriod, `trainingOpts.are: ${trainingOpts.callbackPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.callbackPeriod}`);
+        });
+  
+        it('training options timeout', () => {
+          assert.equal(trainingOpts.timeout, serializedNet.trainOpts.timeout, `trainingOpts.are: ${trainingOpts.timeout} serializedNet should be the same but are: ${serializedNet.trainOpts.timeout}`);
+        });
+      });
     });
 
     it('can run originalNet, and serializedNet, with same output', () => {
diff --git a/test/base/trainopts.js b/test/base/trainopts.js
index e9baa0b75..08c1c47e7 100644
--- a/test/base/trainopts.js
+++ b/test/base/trainopts.js
@@ -85,7 +85,7 @@ describe('async train() options', () => {
         done();
       })
       .catch(err => { assert.ok(false, err.toString()) });
-  });
+  }).timeout(10000);
 
   it('train until max iterations reached', (done) => {
     let net = new brain.NeuralNetwork();
@@ -96,7 +96,7 @@ describe('async train() options', () => {
         done();
       })
       .catch(err => { assert.ok(false, err.toString()) });
-  });
+  }).timeout(10000);
 
   it('asyinc training callback called with training stats', (done) => {
     let iters = 100;
@@ -119,7 +119,7 @@ describe('async train() options', () => {
       done();
     })
     .catch(err => { assert.ok(false, err.toString()) });
-  });
+  }).timeout(10000);
 
   it('learningRate ASYNC - higher learning rate should train faster', (done) => {
     let data = [
@@ -146,7 +146,7 @@ describe('async train() options', () => {
       .catch(err => {
         assert.ok(false, err.toString())
       });
-  }).timeout(5000);
+  }).timeout(10000);
 
   it('momentum ASYNC - higher momentum should train faster', (done) => {
     let data = [
@@ -171,5 +171,5 @@ describe('async train() options', () => {
       }).catch(err => {
         assert.ok(false, err.toString())
       });
-  }).timeout(5000);
+  }).timeout(10000);
 });

From f1a213b9f782fe6a4d1429a30f2335ea5dcd4d87 Mon Sep 17 00:00:00 2001
From: Fred Christensen <fred@ifit.com>
Date: Tue, 30 Jan 2018 09:52:12 -0700
Subject: [PATCH 5/5] Readme updates

---
 README.md      | 2 +-
 test/README.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index a8346a1eb..fe8b22520 100644
--- a/README.md
+++ b/README.md
@@ -149,7 +149,7 @@ The learning rate is a parameter that influences how quickly the network trains.
 
 The momentum is similar to learning rate, expecting a value from `0` to `1` as well but it is multiplied against the next level's change value.  The default value is `0.1`
 
-Any of these training options can be passed into the constructor or passed into the `updateTrainingOptions(opts)` method and they will be saved on the network and used any time you trian.  If you save your network to json, these training options are saved and restored as well (except for callback and if the log is set restored log will be console.log).
+Any of these training options can be passed into the constructor or passed into the `updateTrainingOptions(opts)` method and they will be saved on the network and used any time you trian.  If you save your network to json, these training options are saved and restored as well (except for callback and log, callback will be forgoten and log will be restored using console.log).
 
 ### Async Training
 `trainAsync()` takes the same arguments as train (data and options).  Instead of returning the results object from training it returns a promise that when resolved will return the training results object.
diff --git a/test/README.md b/test/README.md
index f86b66967..d59a69bd8 100644
--- a/test/README.md
+++ b/test/README.md
@@ -12,7 +12,7 @@ Then you can run all tests using `npm test`.
 Run the unit tests with:
 
 ```
-npm run test
+npm test
 ```
 
 See [package.json](../package.json) for more testing examples.