diff --git a/bin/gpu-core.js b/bin/gpu-core.js
new file mode 100644
index 00000000..24760e3f
--- /dev/null
+++ b/bin/gpu-core.js
@@ -0,0 +1,264 @@
+/**
+ * gpu.js
+ * http://gpu.rocks/
+ *
+ * GPU Accelerated JavaScript
+ *
+ * @version 1.10.4
+ * @date Sun Feb 10 2019 20:40:25 GMT-0600 (Central Standard Time)
+ *
+ * @license MIT
+ * The MIT License
+ *
+ * Copyright (c) 2019 gpu.js Team
+ */
+"use strict";(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[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");
+
+module.exports = function () {
+	function GPUCore() {
+		_classCallCheck(this, GPUCore);
+	}
+
+	_createClass(GPUCore, null, [{
+		key: "validateKernelObj",
+
+
+		value: function validateKernelObj(kernelObj) {
+
+			if (kernelObj === null) {
+				throw "KernelObj being validated is NULL";
+			}
+
+			if (typeof kernelObj === "string") {
+				try {
+					kernelObj = JSON.parse(kernelObj);
+				} catch (e) {
+					console.error(e);
+					throw "Failed to convert KernelObj from JSON string";
+				}
+
+				if (kernelObj === null) {
+					throw "Invalid (NULL) KernelObj JSON string representation";
+				}
+			}
+
+			if (kernelObj.isKernelObj !== true) {
+				throw "Failed missing isKernelObj flag check";
+			}
+
+			return kernelObj;
+		}
+
+
+	}, {
+		key: "loadKernelObj",
+		value: function loadKernelObj(kernelObj, inOpt) {
+
+			kernelObj = validateKernelObj(kernelObj);
+		}
+	}]);
+
+	return GPUCore;
+}();
+},{"./utils-core":2}],2:[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 = function () {
+	function UtilsCore() {
+		_classCallCheck(this, UtilsCore);
+	}
+
+	_createClass(UtilsCore, null, [{
+		key: 'isCanvas',
+
+
+
+
+
+		value: function isCanvas(canvasObj) {
+			return canvasObj !== null && (canvasObj.nodeName && canvasObj.getContext && canvasObj.nodeName.toUpperCase() === 'CANVAS' || typeof OffscreenCanvas !== 'undefined' && canvasObj instanceof OffscreenCanvas);
+		}
+
+
+	}, {
+		key: 'isCanvasSupported',
+		value: function isCanvasSupported() {
+			return _isCanvasSupported;
+		}
+
+
+	}, {
+		key: 'initCanvas',
+		value: function initCanvas() {
+			if (!_isCanvasSupported) {
+				return null;
+			}
+
+			var canvas = typeof document !== 'undefined' ? document.createElement('canvas') : new OffscreenCanvas(0, 0);
+
+			canvas.width = 2;
+			canvas.height = 2;
+
+			return canvas;
+		}
+
+
+
+
+	}, {
+		key: 'isWebGl',
+		value: function isWebGl(webGlObj) {
+			return webGlObj && typeof webGlObj.getExtension === 'function';
+		}
+
+
+	}, {
+		key: 'isWebGl2',
+		value: function isWebGl2(webGl2Obj) {
+			return webGl2Obj && typeof WebGL2RenderingContext !== 'undefined' && webGl2Obj instanceof WebGL2RenderingContext;
+		}
+
+
+	}, {
+		key: 'isWebGlSupported',
+		value: function isWebGlSupported() {
+			return _isWebGlSupported;
+		}
+
+
+	}, {
+		key: 'isWebGl2Supported',
+		value: function isWebGl2Supported() {
+			return _isWebGl2Supported;
+		}
+	}, {
+		key: 'isWebGlDrawBuffersSupported',
+		value: function isWebGlDrawBuffersSupported() {
+			return _isWebGlDrawBuffersSupported;
+		}
+
+
+	}, {
+		key: 'initWebGlDefaultOptions',
+		value: function initWebGlDefaultOptions() {
+			return {
+				alpha: false,
+				depth: false,
+				antialias: false
+			};
+		}
+
+
+	}, {
+		key: 'initWebGl',
+		value: function initWebGl(canvasObj) {
+
+			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
+				if (!_isCanvasSupported) {
+					return null;
+				}
+			}
+
+			if (!UtilsCore.isCanvas(canvasObj)) {
+				throw new Error('Invalid canvas object - ' + canvasObj);
+			}
+
+			var webGl = null;
+			var defaultOptions = UtilsCore.initWebGlDefaultOptions();
+			try {
+				webGl = canvasObj.getContext('experimental-webgl', defaultOptions);
+			} catch (e) {
+			}
+
+			if (webGl === null) {
+				webGl = canvasObj.getContext('webgl2', defaultOptions) || canvasObj.getContext('webgl', defaultOptions);
+			}
+
+			if (webGl) {
+				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 webGl;
+		}
+
+
+	}, {
+		key: 'initWebGl2',
+		value: function initWebGl2(canvasObj) {
+
+			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
+				if (!_isCanvasSupported) {
+					return null;
+				}
+			}
+
+			if (!UtilsCore.isCanvas(canvasObj)) {
+				throw new Error('Invalid canvas object - ' + canvasObj);
+			}
+
+			return canvasObj.getContext('webgl2', UtilsCore.initWebGlDefaultOptions());
+		}
+
+
+	}, {
+		key: 'checkOutput',
+		value: function checkOutput(output) {
+			if (!output || !Array.isArray(output)) throw new Error('kernel.output not an array');
+			for (var i = 0; i < output.length; i++) {
+				if (isNaN(output[i]) || output[i] < 1) {
+					throw new Error('kernel.output[' + i + '] incorrectly defined as `' + output[i] + '`, needs to be numeric, and greater than 0');
+				}
+			}
+		}
+	}]);
+
+	return UtilsCore;
+}();
+
+
+var _isCanvasSupported = typeof document !== 'undefined' ? UtilsCore.isCanvas(document.createElement('canvas')) : typeof OffscreenCanvas !== 'undefined';
+var _testingWebGl = UtilsCore.initWebGl(UtilsCore.initCanvas());
+var _testingWebGl2 = UtilsCore.initWebGl2(UtilsCore.initCanvas());
+var _isWebGlSupported = UtilsCore.isWebGl(_testingWebGl);
+var _isWebGl2Supported = UtilsCore.isWebGl2(_testingWebGl2);
+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;
+},{}],3:[function(require,module,exports){
+'use strict';
+
+var GPUCore = require("./core/gpu-core");
+if (typeof module !== 'undefined') {
+	module.exports = GPUCore;
+}
+if (typeof window !== 'undefined') {
+	window.GPUCore = GPUCore;
+	if (window.GPU === null) {
+		window.GPU = GPUCore;
+	}
+}
+},{"./core/gpu-core":1}]},{},[3]);
diff --git a/bin/gpu-core.min.js b/bin/gpu-core.min.js
new file mode 100644
index 00000000..6f281d05
--- /dev/null
+++ b/bin/gpu-core.min.js
@@ -0,0 +1,15 @@
+/**
+ * gpu.js
+ * http://gpu.rocks/
+ *
+ * GPU Accelerated JavaScript
+ *
+ * @version 1.10.4
+ * @date Sun Feb 10 2019 20:40:25 GMT-0600 (Central Standard Time)
+ *
+ * @license MIT
+ * The MIT License
+ *
+ * Copyright (c) 2019 gpu.js Team
+ */
+"use strict";!function(){function e(n,t,r){function i(u,a){if(!t[u]){if(!n[u]){var l="function"==typeof require&&require;if(!a&&l)return l(u,!0);if(o)return o(u,!0);var f=new Error("Cannot find module '"+u+"'");throw f.code="MODULE_NOT_FOUND",f}var c=t[u]={exports:{}};n[u][0].call(c.exports,function(e){var t=n[u][1][e];return i(t||e)},c,c.exports,e,n,t,r)}return t[u].exports}for(var o="function"==typeof require&&require,u=0;u<r.length;u++)i(r[u]);return i}return e}()({1:[function(e,n,t){function r(e,n){if(!(e instanceof n))throw new TypeError("Cannot call a class as a function")}var i=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}}();e("./utils-core");n.exports=function(){function e(){r(this,e)}return i(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(n){throw console.error(n),"Failed to convert KernelObj from JSON string"}if(null===e)throw"Invalid (NULL) KernelObj JSON string representation"}if(e.isKernelObj!==!0)throw"Failed missing isKernelObj flag check";return e}},{key:"loadKernelObj",value:function(e,n){e=validateKernelObj(e)}}]),e}()},{"./utils-core":2}],2:[function(e,n,t){function r(e,n){if(!(e instanceof n))throw new TypeError("Cannot call a class as a function")}var i=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}}(),o=function(){function e(){r(this,e)}return i(e,null,[{key:"isCanvas",value:function(e){return null!==e&&(e.nodeName&&e.getContext&&"CANVAS"===e.nodeName.toUpperCase()||"undefined"!=typeof OffscreenCanvas&&e instanceof OffscreenCanvas)}},{key:"isCanvasSupported",value:function(){return u}},{key:"initCanvas",value:function(){if(!u)return null;var e="undefined"!=typeof document?document.createElement("canvas"):new OffscreenCanvas(0,0);return e.width=2,e.height=2,e}},{key:"isWebGl",value:function(e){return e&&"function"==typeof e.getExtension}},{key:"isWebGl2",value:function(e){return e&&"undefined"!=typeof WebGL2RenderingContext&&e instanceof WebGL2RenderingContext}},{key:"isWebGlSupported",value:function(){return f}},{key:"isWebGl2Supported",value:function(){return c}},{key:"isWebGlDrawBuffersSupported",value:function(){return s}},{key:"initWebGlDefaultOptions",value:function(){return{alpha:!1,depth:!1,antialias:!1}}},{key:"initWebGl",value:function(n){if(("undefined"!=typeof u||null===n)&&!u)return null;if(!e.isCanvas(n))throw new Error("Invalid canvas object - "+n);var t=null,r=e.initWebGlDefaultOptions();try{t=n.getContext("experimental-webgl",r)}catch(i){}return null===t&&(t=n.getContext("webgl2",r)||n.getContext("webgl",r)),t&&(t.OES_texture_float=t.getExtension("OES_texture_float"),t.OES_texture_float_linear=t.getExtension("OES_texture_float_linear"),t.OES_element_index_uint=t.getExtension("OES_element_index_uint")),t}},{key:"initWebGl2",value:function(n){if(("undefined"!=typeof u||null===n)&&!u)return null;if(!e.isCanvas(n))throw new Error("Invalid canvas object - "+n);return n.getContext("webgl2",e.initWebGlDefaultOptions())}},{key:"checkOutput",value:function(e){if(!e||!Array.isArray(e))throw new Error("kernel.output not an array");for(var n=0;n<e.length;n++)if(isNaN(e[n])||e[n]<1)throw new Error("kernel.output["+n+"] incorrectly defined as `"+e[n]+"`, needs to be numeric, and greater than 0")}}]),e}(),u="undefined"!=typeof document?o.isCanvas(document.createElement("canvas")):"undefined"!=typeof OffscreenCanvas,a=o.initWebGl(o.initCanvas()),l=o.initWebGl2(o.initCanvas()),f=o.isWebGl(a),c=o.isWebGl2(l),s=f&&Boolean(a.getExtension("WEBGL_draw_buffers"));f?(o.OES_texture_float=a.OES_texture_float,o.OES_texture_float_linear=a.OES_texture_float_linear,o.OES_element_index_uint=a.OES_element_index_uint):(o.OES_texture_float=!1,o.OES_texture_float_linear=!1,o.OES_element_index_uint=!1),n.exports=o},{}],3:[function(e,n,t){var r=e("./core/gpu-core");"undefined"!=typeof n&&(n.exports=r),"undefined"!=typeof window&&(window.GPUCore=r,null===window.GPU&&(window.GPU=r))},{"./core/gpu-core":1}]},{},[3]);
\ No newline at end of file
diff --git a/bin/gpu.js b/bin/gpu.js
new file mode 100644
index 00000000..1fd3fcdd
--- /dev/null
+++ b/bin/gpu.js
@@ -0,0 +1,11772 @@
+/**
+ * gpu.js
+ * http://gpu.rocks/
+ *
+ * GPU Accelerated JavaScript
+ *
+ * @version 1.10.4
+ * @date Sun Feb 10 2019 20:40:25 GMT-0600 (Central Standard Time)
+ *
+ * @license MIT
+ * The MIT License
+ *
+ * Copyright (c) 2019 gpu.js Team
+ */
+"use strict";(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+'use strict';
+
+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 FunctionBuilderBase = require('../function-builder-base');
+var CPUFunctionNode = require('./function-node');
+
+module.exports = function (_FunctionBuilderBase) {
+  _inherits(CPUFunctionBuilder, _FunctionBuilderBase);
+
+  function CPUFunctionBuilder() {
+    _classCallCheck(this, CPUFunctionBuilder);
+
+    var _this = _possibleConstructorReturn(this, (CPUFunctionBuilder.__proto__ || Object.getPrototypeOf(CPUFunctionBuilder)).call(this));
+
+    _this.Node = CPUFunctionNode;
+    return _this;
+  }
+
+  return CPUFunctionBuilder;
+}(FunctionBuilderBase);
+},{"../function-builder-base":6,"./function-node":2}],2:[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"); } }
+
+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 BaseFunctionNode = require('../function-node-base');
+var utils = require('../../core/utils');
+
+module.exports = function (_BaseFunctionNode) {
+	_inherits(CPUFunctionNode, _BaseFunctionNode);
+
+	function CPUFunctionNode(functionName, jsFunction, options) {
+		_classCallCheck(this, CPUFunctionNode);
+
+		var _this = _possibleConstructorReturn(this, (CPUFunctionNode.__proto__ || Object.getPrototypeOf(CPUFunctionNode)).call(this, functionName, jsFunction, options));
+
+		_this.paramSizes = options ? options.paramSizes : [];
+		_this.memberStates = [];
+		return _this;
+	}
+
+	_createClass(CPUFunctionNode, [{
+		key: 'pushMemberState',
+		value: function pushMemberState(name) {
+			this.memberStates.push(name);
+		}
+	}, {
+		key: 'popMemberState',
+		value: function popMemberState(name) {
+			if (this.memberState === name) {
+				this.memberStates.pop();
+			} else {
+				throw new Error('Cannot popMemberState ' + name + ' when in ' + this.memberState);
+			}
+		}
+	}, {
+		key: 'generate',
+		value: function generate() {
+			if (this.debug) {
+				console.log(this);
+			}
+			this.functionStringArray = this.astGeneric(this.getJsAST(), []);
+			this.functionString = this.functionStringArray.join('').trim();
+			return this.functionString;
+		}
+
+
+	}, {
+		key: 'getFunctionPrototypeString',
+		value: function getFunctionPrototypeString() {
+			if (this.webGlFunctionPrototypeString) {
+				return this.webGlFunctionPrototypeString;
+			}
+			return this.webGlFunctionPrototypeString = this.generate();
+		}
+
+
+	}, {
+		key: 'astFunctionDeclaration',
+		value: function astFunctionDeclaration(ast, retArr) {
+			this.builder.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astFunctionPrototype',
+		value: function astFunctionPrototype(ast, retArr) {
+			if (this.isRootKernel || this.isSubKernel) {
+				return retArr;
+			}
+
+			retArr.push(this.returnType);
+			retArr.push(' ');
+			retArr.push(this.functionName);
+			retArr.push('(');
+
+			for (var i = 0; i < this.paramNames.length; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+				retArr.push('user_');
+				retArr.push(this.paramNames[i]);
+			}
+
+			retArr.push(');\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astFunctionExpression',
+		value: function astFunctionExpression(ast, retArr) {
+
+			if (!this.isRootKernel) {
+				retArr.push('function');
+				retArr.push(' ');
+				retArr.push(this.functionName);
+				retArr.push('(');
+
+				for (var i = 0; i < this.paramNames.length; ++i) {
+					var paramName = this.paramNames[i];
+
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					retArr.push('user_');
+					retArr.push(paramName);
+				}
+
+				retArr.push(') {\n');
+			}
+
+			for (var _i = 0; _i < ast.body.body.length; ++_i) {
+				this.astGeneric(ast.body.body[_i], retArr);
+				retArr.push('\n');
+			}
+
+			if (!this.isRootKernel) {
+				retArr.push('}\n');
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astReturnStatement',
+		value: function astReturnStatement(ast, retArr) {
+			if (this.isRootKernel) {
+				retArr.push('kernelResult = ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+			} else if (this.isSubKernel) {
+				retArr.push(this.functionName + 'Result = ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+				retArr.push('return ' + this.functionName + 'Result;');
+			} else {
+				retArr.push('return ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+			}
+
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astLiteral',
+		value: function astLiteral(ast, retArr) {
+
+			if (isNaN(ast.value)) {
+				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast);
+			}
+
+			retArr.push(ast.value);
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBinaryExpression',
+		value: function astBinaryExpression(ast, retArr) {
+			retArr.push('(');
+			this.astGeneric(ast.left, retArr);
+			retArr.push(ast.operator);
+			this.astGeneric(ast.right, retArr);
+			retArr.push(')');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(idtNode, retArr) {
+			if (idtNode.type !== 'Identifier') {
+				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode);
+			}
+
+			switch (this.state) {
+				case 'input-index-y':
+				case 'input-index-z':
+					retArr.push('(');
+			}
+
+			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;
+				case 'Infinity':
+					retArr.push('Infinity');
+					break;
+				default:
+					if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
+						retArr.push('constants_' + idtNode.name);
+					} else {
+						var userParamName = this.getUserParamName(idtNode.name);
+						if (userParamName !== null) {
+							retArr.push('user_' + userParamName);
+						} else {
+							retArr.push('user_' + idtNode.name);
+						}
+					}
+			}
+
+			switch (this.state) {
+				case 'input-index-y':
+					{
+						var size = this.paramSizes[this.paramNames.indexOf(this.memberState)];
+						retArr.push(' * ' + size[0] + ')');
+						break;
+					}
+				case 'input-index-z':
+					{
+						var _size = this.paramSizes[this.paramNames.indexOf(this.memberState)];
+						retArr.push(' * ' + _size[0] * _size[1] + ')');
+						break;
+					}
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astForStatement',
+		value: function astForStatement(forNode, retArr) {
+			if (forNode.type !== 'ForStatement') {
+				throw this.astErrorOutput('Invalid for statement', forNode);
+			}
+
+			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.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.');
+					}
+
+					retArr.push('for (');
+					this.astGeneric(forNode.init, retArr);
+					if (retArr[retArr.length - 1] !== ';') {
+						retArr.push(';');
+					}
+					this.astGeneric(forNode.test.left, retArr);
+					retArr.push(forNode.test.operator);
+					retArr.push('LOOP_MAX');
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr);
+					retArr.push(')');
+
+					retArr.push('{\n');
+					retArr.push('if (');
+					this.astGeneric(forNode.test.left, retArr);
+					retArr.push(forNode.test.operator);
+					this.astGeneric(forNode.test.right, retArr);
+					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);
+						}
+					} else {
+						this.astGeneric(forNode.body, retArr);
+					}
+					retArr.push('} else {\n');
+					retArr.push('break;\n');
+					retArr.push('}\n');
+					retArr.push('}\n');
+
+					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');
+					}
+
+					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);
+								retArr.push(';');
+							}
+						}
+
+						retArr.push('for (let ');
+						this.astGeneric(initArgument, retArr);
+						retArr.push(';');
+					} else {
+						retArr.push('for (');
+						this.astGeneric(forNode.init, retArr);
+					}
+
+					this.astGeneric(forNode.test, retArr);
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr);
+					retArr.push(')');
+					this.astGeneric(forNode.body, retArr);
+					return retArr;
+				}
+			}
+
+			throw this.astErrorOutput('Invalid for statement', forNode);
+		}
+
+
+	}, {
+		key: 'astWhileStatement',
+		value: function astWhileStatement(whileNode, retArr) {
+			if (whileNode.type !== 'WhileStatement') {
+				throw this.astErrorOutput('Invalid while statement', whileNode);
+			}
+
+			retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
+			retArr.push('if (');
+			this.astGeneric(whileNode.test, retArr);
+			retArr.push(') {\n');
+			this.astGeneric(whileNode.body, retArr);
+			retArr.push('} else {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astDoWhileStatement',
+		value: function astDoWhileStatement(doWhileNode, retArr) {
+			if (doWhileNode.type !== 'DoWhileStatement') {
+				throw this.astErrorOutput('Invalid while statement', doWhileNode);
+			}
+
+			retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
+			this.astGeneric(doWhileNode.body, retArr);
+			retArr.push('if (!');
+			this.astGeneric(doWhileNode.test, retArr);
+			retArr.push(') {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astAssignmentExpression',
+		value: function astAssignmentExpression(assNode, retArr) {
+			this.astGeneric(assNode.left, retArr);
+			retArr.push(assNode.operator);
+			this.astGeneric(assNode.right, retArr);
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astEmptyStatement',
+		value: function astEmptyStatement(eNode, retArr) {
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBlockStatement',
+		value: function astBlockStatement(bNode, retArr) {
+			retArr.push('{\n');
+			for (var i = 0; i < bNode.body.length; i++) {
+				this.astGeneric(bNode.body[i], retArr);
+			}
+			retArr.push('}\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astExpressionStatement',
+		value: function astExpressionStatement(esNode, retArr) {
+			this.astGeneric(esNode.expression, retArr);
+			retArr.push(';');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astVariableDeclaration',
+		value: function astVariableDeclaration(vardecNode, retArr) {
+			retArr.push('var ');
+			for (var i = 0; i < vardecNode.declarations.length; i++) {
+				this.declarations[vardecNode.declarations[i].id.name] = 'var';
+				if (i > 0) {
+					retArr.push(',');
+				}
+				this.astGeneric(vardecNode.declarations[i], retArr);
+			}
+			retArr.push(';');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astVariableDeclarator',
+		value: function astVariableDeclarator(ivardecNode, retArr) {
+			this.astGeneric(ivardecNode.id, retArr);
+			if (ivardecNode.init !== null) {
+				retArr.push('=');
+				this.astGeneric(ivardecNode.init, retArr);
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astIfStatement',
+		value: function astIfStatement(ifNode, retArr) {
+			retArr.push('if (');
+			this.astGeneric(ifNode.test, retArr);
+			retArr.push(')');
+			if (ifNode.consequent.type === 'BlockStatement') {
+				this.astGeneric(ifNode.consequent, retArr);
+			} else {
+				retArr.push(' {\n');
+				this.astGeneric(ifNode.consequent, retArr);
+				retArr.push('\n}\n');
+			}
+
+			if (ifNode.alternate) {
+				retArr.push('else ');
+				if (ifNode.alternate.type === 'BlockStatement') {
+					this.astGeneric(ifNode.alternate, retArr);
+				} else {
+					retArr.push(' {\n');
+					this.astGeneric(ifNode.alternate, retArr);
+					retArr.push('\n}\n');
+				}
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBreakStatement',
+		value: function astBreakStatement(brNode, retArr) {
+			retArr.push('break;\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astContinueStatement',
+		value: function astContinueStatement(crNode, retArr) {
+			retArr.push('continue;\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astLogicalExpression',
+		value: function astLogicalExpression(logNode, retArr) {
+			retArr.push('(');
+			this.astGeneric(logNode.left, retArr);
+			retArr.push(logNode.operator);
+			this.astGeneric(logNode.right, retArr);
+			retArr.push(')');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astUpdateExpression',
+		value: function astUpdateExpression(uNode, retArr) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr);
+			} else {
+				this.astGeneric(uNode.argument, retArr);
+				retArr.push(uNode.operator);
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astUnaryExpression',
+		value: function astUnaryExpression(uNode, retArr) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr);
+			} else {
+				this.astGeneric(uNode.argument, retArr);
+				retArr.push(uNode.operator);
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astThisExpression',
+		value: function astThisExpression(tNode, retArr) {
+			retArr.push('_this');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astMemberExpression',
+		value: function astMemberExpression(mNode, retArr) {
+			if (mNode.computed) {
+				if (mNode.object.type === 'Identifier' || mNode.object.type === 'MemberExpression' && mNode.object.object.object && mNode.object.object.object.type === 'ThisExpression' && mNode.object.object.property.name === 'constants') {
+					this.pushState('identifier');
+					this.astGeneric(mNode.object, retArr);
+					this.popState('identifier');
+					retArr.push('[');
+					if (this.isInput(mNode.object.name)) {
+						this.astGeneric(mNode.property, retArr);
+					} else {
+						this.astGeneric(mNode.property, retArr);
+					}
+					retArr.push(']');
+				} else {
+					if (mNode.object.object) {
+						if (mNode.object.object.object && this.isInput(mNode.object.object.object.name)) {
+							this.pushMemberState(mNode.object.object.object.name);
+							this.pushState('input-index-z');
+							this.astGeneric(mNode.object, retArr);
+							var last = retArr.pop();
+							retArr.push(' + ');
+							this.popState('input-index-z');
+							this.pushState('input-index');
+							this.astGeneric(mNode.property, retArr);
+							this.popState('input-index');
+							retArr.push(last);
+							this.popMemberState(mNode.object.object.object.name);
+						} else if (this.isInput(mNode.object.object.name)) {
+							this.pushMemberState(mNode.object.object.name);
+							if (!this.isState('input-index-z')) {
+								this.pushState('input-index-y');
+							}
+							this.astGeneric(mNode.object, retArr);
+							var _last = retArr.pop();
+							retArr.push(' + ');
+							if (!this.isState('input-index-z')) {
+								this.popState('input-index-y');
+							}
+
+							var isInputIndexZ = this.isState('input-index-z');
+							if (isInputIndexZ) {
+								this.pushState('input-index-y');
+							} else {
+								this.pushState('input-index');
+							}
+							this.astGeneric(mNode.property, retArr);
+							if (isInputIndexZ) {
+								this.popState('input-index-y');
+							} else {
+								this.popState('input-index');
+							}
+							retArr.push(_last);
+							this.popMemberState(mNode.object.object.name);
+						} else {
+							this.astGeneric(mNode.object, retArr);
+							var _last2 = retArr.pop();
+							retArr.push('][');
+							this.astGeneric(mNode.property, retArr);
+							retArr.push(_last2);
+						}
+					} else {
+						this.astGeneric(mNode.object, retArr);
+						var _last3 = retArr.pop();
+						retArr.push('][');
+						this.astGeneric(mNode.property, retArr);
+						retArr.push(_last3);
+					}
+				}
+			} else {
+				var unrolled = this.astMemberExpressionUnroll(mNode);
+				if (mNode.property.type === 'Identifier' && mNode.computed) {
+					unrolled = 'user_' + unrolled;
+				}
+
+				if (unrolled.indexOf('this.constants') === 0) {
+					unrolled = 'constants_' + unrolled.substring(15);
+				} else if (unrolled.indexOf('this') === 0) {
+					unrolled = '_' + unrolled;
+				}
+
+				switch (this.state) {
+					case 'input-index-y':
+					case 'input-index-z':
+						retArr.push('(');
+				}
+
+				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:
+						if (mNode.object && mNode.object.name && this.declarations[mNode.object.name]) {
+							retArr.push('user_');
+						}
+						retArr.push(unrolled);
+				}
+
+				switch (this.state) {
+					case 'input-index-y':
+						{
+							var size = this.paramSizes[this.paramNames.indexOf(this.memberState)];
+							retArr.push(' * ' + size[0] + ')');
+							break;
+						}
+					case 'input-index-z':
+						{
+							var _size2 = this.paramSizes[this.paramNames.indexOf(this.memberState)];
+							retArr.push(' * ' + _size2[0] * _size2[1] + ')');
+							break;
+						}
+				}
+			}
+			return retArr;
+		}
+	}, {
+		key: 'astSequenceExpression',
+		value: function astSequenceExpression(sNode, retArr) {
+			for (var i = 0; i < sNode.expressions.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
+				}
+				this.astGeneric(sNode.expressions, retArr);
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astCallExpression',
+		value: function astCallExpression(ast, retArr) {
+			if (ast.callee) {
+				var funcName = this.astMemberExpressionUnroll(ast.callee);
+
+				if (this.calledFunctions.indexOf(funcName) < 0) {
+					this.calledFunctions.push(funcName);
+				}
+				if (!this.hasOwnProperty('funcName')) {
+					this.calledFunctionsArguments[funcName] = [];
+				}
+
+				var functionArguments = [];
+				this.calledFunctionsArguments[funcName].push(functionArguments);
+
+				retArr.push(funcName);
+
+				retArr.push('(');
+
+				for (var i = 0; i < ast.arguments.length; ++i) {
+					var argument = ast.arguments[i];
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					this.astGeneric(argument, retArr);
+					if (argument.type === 'Identifier') {
+						var paramIndex = this.paramNames.indexOf(argument.name);
+						if (paramIndex === -1) {
+							functionArguments.push(null);
+						} else {
+							functionArguments.push({
+								name: argument.name,
+								type: this.paramTypes[paramIndex]
+							});
+						}
+					} else {
+						functionArguments.push(null);
+					}
+				}
+
+				retArr.push(')');
+
+				return retArr;
+			}
+
+			throw this.astErrorOutput('Unknown CallExpression', ast);
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astArrayExpression',
+		value: function astArrayExpression(arrNode, retArr) {
+			var arrLen = arrNode.elements.length;
+
+			retArr.push('[');
+			for (var i = 0; i < arrLen; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+				var subNode = arrNode.elements[i];
+				this.astGeneric(subNode, retArr);
+			}
+			retArr.push(']');
+
+			return retArr;
+
+		}
+	}, {
+		key: 'astDebuggerStatement',
+		value: function astDebuggerStatement(arrNode, retArr) {
+			retArr.push('debugger;');
+			return retArr;
+		}
+	}, {
+		key: 'memberState',
+		get: function get() {
+			return this.memberStates[this.memberStates.length - 1];
+		}
+	}]);
+
+	return CPUFunctionNode;
+}(BaseFunctionNode);
+},{"../../core/utils":32,"../function-node-base":7}],3:[function(require,module,exports){
+'use strict';
+
+var utils = require('../../core/utils');
+var kernelRunShortcut = require('../kernel-run-shortcut');
+
+function removeFnNoise(fn) {
+  if (/^function /.test(fn)) {
+    fn = fn.substring(9);
+  }
+  return fn.replace(/[_]typeof/g, 'typeof');
+}
+
+function removeNoise(str) {
+  return str.replace(/[_]typeof/g, 'typeof');
+}
+
+module.exports = function (cpuKernel, name) {
+  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: ' + removeNoise(utils.allPropertiesOf.toString()) + ',\n      clone: ' + removeNoise(utils.clone.toString()) + ',\n      checkOutput: ' + removeNoise(utils.checkOutput.toString()) + '\n    };\n    const Utils = utils;\n    let Input = function() {};\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      setInput(Type) { Input = Type; }\n      ' + removeFnNoise(cpuKernel.build.toString()) + '\n      ' + removeFnNoise(cpuKernel.setupParams.toString()) + '\n      ' + removeFnNoise(cpuKernel.setupConstants.toString()) + '\n      run () { ' + cpuKernel.kernelString + ' }\n      getKernelString() { return this._kernelString; }\n      ' + removeFnNoise(cpuKernel.validateOptions.toString()) + '\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
+};
+},{"../../core/utils":32,"../kernel-run-shortcut":9}],4:[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"); } }
+
+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 KernelBase = require('../kernel-base');
+var utils = require('../../core/utils');
+var kernelString = require('./kernel-string');
+
+module.exports = function (_KernelBase) {
+	_inherits(CPUKernel, _KernelBase);
+
+	function CPUKernel(fnString, settings) {
+		_classCallCheck(this, CPUKernel);
+
+		var _this = _possibleConstructorReturn(this, (CPUKernel.__proto__ || Object.getPrototypeOf(CPUKernel)).call(this, fnString, settings));
+
+		_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;
+	}
+
+
+
+	_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 === 'NumberTexture' || argType === 'ArrayTexture(4)') {
+					this.output = arguments[0].output;
+				} else {
+					throw 'Auto dimensions not supported for input type: ' + argType;
+				}
+			}
+
+			utils.checkOutput(this.output);
+		}
+
+
+	}, {
+		key: 'build',
+		value: function build() {
+			this.setupConstants();
+			this.setupParams(arguments);
+			this.validateOptions();
+			var canvas = this._canvas;
+			if (canvas) {
+				this._canvasCtx = canvas.getContext('2d');
+			}
+			var threadDim = this.threadDim = utils.clone(this.output);
+
+			while (threadDim.length < 3) {
+				threadDim.push(1);
+			}
+
+			if (this.graphical) {
+				var _canvas = this._canvas;
+				if (!_canvas) {
+					throw new Error('no canvas available for using graphical output');
+				}
+				_canvas.width = threadDim[0];
+				_canvas.height = threadDim[1];
+				this._imageData = this._canvasCtx.createImageData(threadDim[0], threadDim[1]);
+				this._colorData = new Uint8ClampedArray(threadDim[0] * threadDim[1] * 4);
+			}
+
+			var kernelString = this.getKernelString();
+
+			if (this.debug) {
+				console.log('Options:');
+				console.dir(this);
+				console.log('Function output:');
+				console.log(kernelString);
+			}
+
+			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;
+			}
+
+			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;
+		}
+
+
+	}, {
+		key: 'getKernelString',
+		value: function getKernelString() {
+			if (this._kernelString !== null) return this._kernelString;
+
+			var builder = this.functionBuilder;
+
+			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: threadDim,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				paramNames: this.paramNames,
+				paramTypes: this.paramTypes,
+				paramSizes: this.paramSizes,
+				constantTypes: this.constantTypes
+			});
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: threadDim
+			});
+
+			builder.addNativeFunctions(this.nativeFunctions);
+
+			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('kernel');
+			var kernel = null;
+			if (prototypes.length > 1) {
+				prototypes = prototypes.filter(function (fn) {
+					if (/^function/.test(fn)) return fn;
+					kernel = fn;
+					return false;
+				});
+			} else {
+				kernel = prototypes.shift();
+			}
+			var kernelString = this._kernelString = '\n\t\tvar LOOP_MAX = ' + this._getLoopMaxString() + '\n\t\tvar constants = this.constants;\n\t\tvar _this = this;\n    return function (' + this.paramNames.map(function (paramName) {
+				return 'user_' + paramName;
+			}).join(', ') + ') {\n      ' + this._processConstants() + '\n      ' + this._processParams() + '\n      ' + this._kernelLoop(kernel) + '\n      if (this.graphical) {\n        this._imageData.data.set(this._colorData);\n        this._canvasCtx.putImageData(this._imageData, 0, 0);\n        return;\n      }\n      ' + this._kernelOutput() + '\n      ' + (prototypes.length > 0 ? prototypes.join('\n') : '') + '\n    }.bind(this);';
+			return kernelString;
+		}
+
+
+	}, {
+		key: 'toString',
+		value: function toString() {
+			return kernelString(this);
+		}
+
+
+	}, {
+		key: '_getLoopMaxString',
+		value: function _getLoopMaxString() {
+			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + ';\n' : ' 1000;\n';
+		}
+	}, {
+		key: '_processConstants',
+		value: function _processConstants() {
+			if (!this.constants) return '';
+
+			var result = [];
+			for (var p in this.constants) {
+				var type = this.constantTypes[p];
+				switch (type) {
+					case 'HTMLImage':
+						result.push('  var constants_' + p + ' = this._imageTo2DArray(this.constants.' + p + ')');
+						break;
+					case 'HTMLImageArray':
+						result.push('  var constants_' + p + ' = this._imageTo3DArray(this.constants.' + p + ')');
+						break;
+					case 'Input':
+						result.push('  var constants_' + p + ' = this.constants.' + p + '.value');
+						break;
+					default:
+						result.push('  var constants_' + p + ' = this.constants.' + p);
+				}
+			}
+			return result.join('\n');
+		}
+	}, {
+		key: '_processParams',
+		value: function _processParams() {
+			var result = [];
+			for (var i = 0; i < this.paramTypes.length; i++) {
+				switch (this.paramTypes[i]) {
+					case 'HTMLImage':
+						result.push('  user_' + this.paramNames[i] + ' = this._imageTo2DArray(user_' + this.paramNames[i] + ')');
+						break;
+					case 'HTMLImageArray':
+						result.push('  user_' + this.paramNames[i] + ' = this._imageTo3DArray(user_' + this.paramNames[i] + ')');
+						break;
+					case 'Input':
+						result.push('  user_' + this.paramNames[i] + ' = user_' + this.paramNames[i] + '.value');
+						break;
+				}
+			}
+			return result.join(';\n');
+		}
+	}, {
+		key: '_imageTo2DArray',
+		value: function _imageTo2DArray(image) {
+			var canvas = this._canvas;
+			if (canvas.width < image.width) {
+				canvas.width = image.width;
+			}
+			if (canvas.height < image.height) {
+				canvas.height = image.height;
+			}
+			var ctx = this._canvasCtx;
+			ctx.drawImage(image, 0, 0, image.width, image.height);
+			var pixelsData = ctx.getImageData(0, 0, image.width, image.height).data;
+			var imageArray = new Array(image.height);
+			var index = 0;
+			for (var y = image.height - 1; y >= 0; y--) {
+				imageArray[y] = new Array(image.width);
+				for (var x = 0; x < image.width; x++) {
+					var r = pixelsData[index++] / 255;
+					var g = pixelsData[index++] / 255;
+					var b = pixelsData[index++] / 255;
+					var a = pixelsData[index++] / 255;
+					var result = [r, g, b, a];
+					result.r = r;
+					result.g = g;
+					result.b = b;
+					result.a = a;
+					imageArray[y][x] = result;
+				}
+			}
+			return imageArray;
+		}
+	}, {
+		key: '_imageTo3DArray',
+		value: function _imageTo3DArray(images) {
+			var imagesArray = new Array(images.length);
+			for (var i = 0; i < images.length; i++) {
+				imagesArray[i] = this._imageTo2DArray(images[i]);
+			}
+			return imagesArray;
+		}
+	}, {
+		key: '_kernelLoop',
+		value: function _kernelLoop(kernelString) {
+			switch (this.output.length) {
+				case 1:
+					return this._kernel1DLoop(kernelString);
+				case 2:
+					return this._kernel2DLoop(kernelString);
+				case 3:
+					return this._kernel3DLoop(kernelString);
+				default:
+					throw new Error('unsupported size kernel');
+			}
+		}
+	}, {
+		key: '_kernel1DLoop',
+		value: function _kernel1DLoop(kernelString) {
+			var threadDim = this.threadDim;
+			return '\n    var result = new Float32Array(' + threadDim[0] + ');\n    ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + ' = new Float32Array(' + threadDim[0] + ');\n';
+			}).join('') + '\n    for (var x = 0; x < ' + threadDim[0] + '; x++) {\n      this.thread.x = x;\n      this.thread.y = 0;\n      this.thread.z = 0;\n      var kernelResult;\n      ' + kernelString + '\n      result[x] = kernelResult;\n      ' + this._mapSubKernels(function (name) {
+				return 'result_' + name + '[x] = ' + name + ';\n';
+			}).join('') + '\n    }';
+		}
+	}, {
+		key: '_kernel2DLoop',
+		value: function _kernel2DLoop(kernelString) {
+			var threadDim = this.threadDim;
+			return '\n    var result = new Array(' + threadDim[1] + ');\n    ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + ' = new Array(' + threadDim[1] + ');\n';
+			}).join('') + '\n    for (var y = 0; y < ' + threadDim[1] + '; y++) {\n      this.thread.z = 0;\n      this.thread.y = y;\n      var resultX = result[y] = new Float32Array(' + threadDim[0] + ');\n      ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + 'X = result_' + name + '[y] = new Float32Array(' + threadDim[0] + ');\n';
+			}).join('') + '\n      for (var x = 0; x < ' + threadDim[0] + '; x++) {\n      \tthis.thread.x = x;\n        var kernelResult;\n        ' + kernelString + '\n        resultX[x] = kernelResult;\n        ' + this._mapSubKernels(function (name) {
+				return 'result_' + name + 'X[x] = ' + name + ';\n';
+			}).join('') + '\n      }\n    }';
+		}
+	}, {
+		key: '_kernel3DLoop',
+		value: function _kernel3DLoop(kernelString) {
+			var threadDim = this.threadDim;
+			return '\n    var result = new Array(' + threadDim[2] + ');\n    ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + ' = new Array(' + threadDim[2] + ');\n';
+			}).join('') + '\n    for (var z = 0; z < ' + threadDim[2] + '; z++) {\n      this.thread.z = z;\n      var resultY = result[z] = new Array(' + threadDim[1] + ');\n      ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + 'Y = result_' + name + '[z] = new Array(' + threadDim[1] + ');\n';
+			}).join('') + '\n      for (var y = 0; y < ' + threadDim[1] + '; y++) {\n        this.thread.y = y;\n        var resultX = resultY[y] = new Float32Array(' + threadDim[0] + ');\n        ' + this._mapSubKernels(function (name) {
+				return 'var result_' + name + 'X = result_' + name + 'Y[y] = new Float32Array(' + threadDim[0] + ');\n';
+			}).join('') + '\n        for (var x = 0; x < ' + threadDim[0] + '; x++) {\n        \tthis.thread.x = x;\n          var kernelResult;\n          ' + kernelString + '\n          resultX[x] = kernelResult;\n          ' + this._mapSubKernels(function (name) {
+				return 'result_' + name + 'X[x] = ' + name + ';\n';
+			}).join('') + '\n        }\n      }\n    }';
+		}
+	}, {
+		key: '_kernelOutput',
+		value: function _kernelOutput() {
+			var _this2 = this;
+
+			if (!this.subKernelOutputVariableNames) {
+				return 'return result;';
+			}
+			return 'return {\n      result: result,\n      ' + Object.keys(this.subKernelProperties || this.subKernelOutputVariableNames).map(function (name, i) {
+				return name + ': result_' + _this2.subKernelOutputVariableNames[i];
+			}).join(',\n') + '\n    };';
+		}
+	}, {
+		key: '_mapSubKernels',
+		value: function _mapSubKernels(fn) {
+			return this.subKernelOutputVariableNames === null ? [''] : this.subKernelOutputVariableNames.map(fn);
+		}
+	}]);
+
+	return CPUKernel;
+}(KernelBase);
+},{"../../core/utils":32,"../kernel-base":8,"./kernel-string":3}],5:[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"); } }
+
+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 utils = require('../../core/utils');
+var RunnerBase = require('../runner-base');
+var CPUKernel = require('./kernel');
+var CPUFunctionBuilder = require('./function-builder');
+
+module.exports = function (_RunnerBase) {
+	_inherits(CPURunner, _RunnerBase);
+
+
+	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;
+	}
+
+
+
+	_createClass(CPURunner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'cpu';
+		}
+	}]);
+
+	return CPURunner;
+}(RunnerBase);
+},{"../../core/utils":32,"../runner-base":10,"./function-builder":1,"./kernel":4}],6:[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"); } }
+
+module.exports = function () {
+
+	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;
+		}
+
+
+	}, {
+		key: 'addFunction',
+		value: function addFunction(functionName, jsFunction, options) {
+			this.addFunctionNode(new this.Node(functionName, jsFunction, options).setBuilder(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]);
+			}
+		}
+
+
+	}, {
+		key: 'addFunctionNode',
+		value: function addFunctionNode(inNode) {
+			this.nodeMap[inNode.functionName] = inNode;
+			if (inNode.isRootKernel) {
+				this.rootKernel = inNode;
+			}
+		}
+
+
+	}, {
+		key: 'traceFunctionCalls',
+		value: function traceFunctionCalls(functionName, retList, parent) {
+			functionName = functionName || 'kernel';
+			retList = retList || [];
+
+			var fNode = this.nodeMap[functionName];
+			if (fNode) {
+				var functionIndex = retList.indexOf(functionName);
+				if (functionIndex === -1) {
+					retList.push(functionName);
+					if (parent) {
+						fNode.parent = parent;
+					}
+					fNode.getFunctionString(); 
+					for (var i = 0; i < fNode.calledFunctions.length; ++i) {
+						this.traceFunctionCalls(fNode.calledFunctions[i], retList, fNode);
+					}
+				} else {
+					var dependantFunctionName = retList.splice(functionIndex, 1)[0];
+					retList.push(dependantFunctionName);
+				}
+			}
+
+			if (this.nativeFunctions[functionName]) {
+				if (retList.indexOf(functionName) >= 0) {
+				} else {
+					retList.push(functionName);
+				}
+			}
+
+			return retList;
+		}
+
+
+	}, {
+		key: 'addKernel',
+		value: function addKernel(fnString, options) {
+			var kernelNode = new this.Node('kernel', fnString, options);
+			kernelNode.setBuilder(this);
+			kernelNode.isRootKernel = true;
+			this.addFunctionNode(kernelNode);
+			return kernelNode;
+		}
+
+
+	}, {
+		key: 'addSubKernel',
+		value: function addSubKernel(jsFunction, options) {
+			var kernelNode = new this.Node(null, jsFunction, options);
+			kernelNode.setBuilder(this);
+			kernelNode.isSubKernel = true;
+			this.addFunctionNode(kernelNode);
+			return kernelNode;
+		}
+
+
+	}, {
+		key: 'getPrototypeString',
+		value: function getPrototypeString(functionName) {
+			return this.getPrototypes(functionName).join('\n');
+		}
+
+
+	}, {
+		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));
+		}
+
+
+	}, {
+		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');
+		}
+
+
+	}, {
+		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;
+		}
+
+
+	}, {
+		key: 'getPrototypeStringFromFunctionNames',
+		value: function getPrototypeStringFromFunctionNames(functionList, opt) {
+			return this.getPrototypesFromFunctionNames(functionList, opt).toString();
+		}
+
+
+	}, {
+		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);
+		}
+	}]);
+
+	return FunctionBuilderBase;
+}();
+},{}],7:[function(require,module,exports){
+'use strict';
+
+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 utils = require('../core/utils');
+var acorn = require('acorn');
+
+module.exports = function () {
+
+	function BaseFunctionNode(functionName, jsFunction, options) {
+		_classCallCheck(this, BaseFunctionNode);
+
+		this.calledFunctions = [];
+		this.calledFunctionsArguments = {};
+		this.builder = null;
+		this.isRootKernel = false;
+		this.isSubKernel = false;
+		this.parent = null;
+		this.debug = null;
+		this.prototypeOnly = null;
+		this.constants = null;
+		this.output = null;
+		this.declarations = {};
+		this.states = [];
+		this.fixIntegerDivisionAccuracy = null;
+
+		var paramTypes = void 0;
+		var returnType = void 0;
+		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 (options.hasOwnProperty('paramTypes')) {
+				this.paramTypes = paramTypes = options.paramTypes;
+			}
+			if (options.hasOwnProperty('constantTypes')) {
+				this.constantTypes = options.constantTypes;
+			} else {
+				this.constantTypes = {};
+			}
+			if (options.hasOwnProperty('returnType')) {
+				returnType = options.returnType;
+			}
+			if (options.hasOwnProperty('fixIntegerDivisionAccuracy')) {
+				this.fixIntegerDivisionAccuracy = options.fixIntegerDivisionAccuracy;
+			}
+		}
+
+		if (!jsFunction) {
+			throw 'jsFunction, parameter is missing';
+		}
+
+		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?';
+		}
+
+		if (!utils.isFunction(jsFunction)) {
+			this.jsFunction = null;
+		} else {
+			this.jsFunction = jsFunction;
+		}
+
+		this.functionName = functionName || jsFunction && jsFunction.name || utils.getFunctionNameFromString(this.jsFunctionString);
+
+		if (!this.functionName) {
+			throw 'jsFunction, missing name argument or value';
+		}
+
+		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 'Number';
+						}
+					});
+				}
+			}
+		} else {
+			this.paramTypes = [];
+		}
+
+		if (!this.returnType) {
+			this.returnType = returnType || 'Number';
+		}
+	}
+
+	_createClass(BaseFunctionNode, [{
+		key: 'isIdentifierConstant',
+		value: function isIdentifierConstant(paramName) {
+			if (!this.constants) return false;
+			return this.constants.hasOwnProperty(paramName);
+		}
+	}, {
+		key: 'isInput',
+		value: function isInput(paramName) {
+			return this.paramTypes[this.paramNames.indexOf(paramName)] === 'Input';
+		}
+	}, {
+		key: 'setBuilder',
+		value: function setBuilder(builder) {
+			this.builder = builder;
+			return this;
+		}
+	}, {
+		key: 'pushState',
+		value: function pushState(state) {
+			this.states.push(state);
+		}
+	}, {
+		key: 'popState',
+		value: function popState(state) {
+			if (this.state !== state) {
+				throw new Error('Cannot popState ' + state + ' when in ' + this.state);
+			}
+			this.states.pop();
+		}
+	}, {
+		key: 'isState',
+		value: function isState(state) {
+			return this.state === state;
+		}
+	}, {
+		key: 'getJsFunction',
+
+
+		value: function getJsFunction() {
+			if (this.jsFunction) {
+				return this.jsFunction;
+			}
+
+			if (this.jsFunctionString) {
+				this.jsFunction = eval(this.jsFunctionString);
+				return this.jsFunction;
+			}
+
+			throw 'Missing jsFunction, and jsFunctionString parameter';
+		}
+
+
+	}, {
+		key: 'astMemberExpressionUnroll',
+		value: function astMemberExpressionUnroll(ast) {
+			if (ast.type === 'Identifier') {
+				return ast.name;
+			} else if (ast.type === 'ThisExpression') {
+				return 'this';
+			}
+
+			if (ast.type === 'MemberExpression') {
+				if (ast.object && ast.property) {
+					if (ast.object.hasOwnProperty('name') && ast.object.name[0] === '_') {
+						return this.astMemberExpressionUnroll(ast.property);
+					}
+
+					return this.astMemberExpressionUnroll(ast.object) + '.' + this.astMemberExpressionUnroll(ast.property);
+				}
+			}
+
+			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]);
+				}
+			}
+
+			throw this.astErrorOutput('Unknown CallExpression_unroll', ast);
+		}
+
+
+	}, {
+		key: 'getJsAST',
+		value: function getJsAST(inParser) {
+			if (this.jsFunctionAST) {
+				return this.jsFunctionAST;
+			}
+
+			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';
+			}
+
+			var funcAST = ast.body[0].declarations[0].init;
+			this.jsFunctionAST = funcAST;
+
+			return funcAST;
+		}
+
+
+	}, {
+		key: 'getFunctionString',
+		value: function getFunctionString() {
+			this.generate();
+			return this.functionString;
+		}
+
+
+	}, {
+		key: 'setFunctionString',
+		value: function setFunctionString(functionString) {
+			this.functionString = functionString;
+		}
+
+
+	}, {
+		key: 'getParamType',
+		value: function getParamType(paramName) {
+			var paramIndex = this.paramNames.indexOf(paramName);
+			if (paramIndex === -1) {
+				if (this.declarations.hasOwnProperty(paramName)) {
+					return this.declarations[paramName];
+				} else {
+					return 'Number';
+				}
+			} else {
+				if (!this.parent) {
+					if (this.paramTypes[paramIndex]) return this.paramTypes[paramIndex];
+				} else {
+					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 'Number';
+		}
+	}, {
+		key: 'getConstantType',
+		value: function getConstantType(constantName) {
+			if (this.constantTypes[constantName]) {
+				return this.constantTypes[constantName];
+			}
+			return null;
+		}
+
+
+	}, {
+		key: 'getUserParamName',
+		value: function getUserParamName(paramName) {
+			var paramIndex = this.paramNames.indexOf(paramName);
+			if (paramIndex === -1) return null;
+			if (!this.parent || !this.isSubKernel) return null;
+			var calledFunctionArguments = this.parent.calledFunctionsArguments[this.functionName];
+			for (var i = 0; i < calledFunctionArguments.length; i++) {
+				var calledFunctionArgument = calledFunctionArguments[i];
+				var param = calledFunctionArgument[paramIndex];
+				if (param !== null && param.type !== 'Integer') {
+					return param.name;
+				}
+			}
+			return null;
+		}
+	}, {
+		key: 'generate',
+		value: function generate(options) {
+			throw new Error('generate not defined on BaseFunctionNode');
+		}
+
+
+	}, {
+		key: 'astGeneric',
+		value: function astGeneric(ast, retArr) {
+			if (ast === null) {
+				throw this.astErrorOutput('NULL ast', ast);
+			} else {
+				if (Array.isArray(ast)) {
+					for (var i = 0; i < ast.length; i++) {
+						this.astGeneric(ast[i], retArr);
+					}
+					return retArr;
+				}
+
+				switch (ast.type) {
+					case 'FunctionDeclaration':
+						return this.astFunctionDeclaration(ast, retArr);
+					case 'FunctionExpression':
+						return this.astFunctionExpression(ast, retArr);
+					case 'ReturnStatement':
+						return this.astReturnStatement(ast, retArr);
+					case 'Literal':
+						return this.astLiteral(ast, retArr);
+					case 'BinaryExpression':
+						return this.astBinaryExpression(ast, retArr);
+					case 'Identifier':
+						return this.astIdentifierExpression(ast, retArr);
+					case 'AssignmentExpression':
+						return this.astAssignmentExpression(ast, retArr);
+					case 'ExpressionStatement':
+						return this.astExpressionStatement(ast, retArr);
+					case 'EmptyStatement':
+						return this.astEmptyStatement(ast, retArr);
+					case 'BlockStatement':
+						return this.astBlockStatement(ast, retArr);
+					case 'IfStatement':
+						return this.astIfStatement(ast, retArr);
+					case 'BreakStatement':
+						return this.astBreakStatement(ast, retArr);
+					case 'ContinueStatement':
+						return this.astContinueStatement(ast, retArr);
+					case 'ForStatement':
+						return this.astForStatement(ast, retArr);
+					case 'WhileStatement':
+						return this.astWhileStatement(ast, retArr);
+					case 'DoWhileStatement':
+						return this.astDoWhileStatement(ast, retArr);
+					case 'VariableDeclaration':
+						return this.astVariableDeclaration(ast, retArr);
+					case 'VariableDeclarator':
+						return this.astVariableDeclarator(ast, retArr);
+					case 'ThisExpression':
+						return this.astThisExpression(ast, retArr);
+					case 'SequenceExpression':
+						return this.astSequenceExpression(ast, retArr);
+					case 'UnaryExpression':
+						return this.astUnaryExpression(ast, retArr);
+					case 'UpdateExpression':
+						return this.astUpdateExpression(ast, retArr);
+					case 'LogicalExpression':
+						return this.astLogicalExpression(ast, retArr);
+					case 'MemberExpression':
+						return this.astMemberExpression(ast, retArr);
+					case 'CallExpression':
+						return this.astCallExpression(ast, retArr);
+					case 'ArrayExpression':
+						return this.astArrayExpression(ast, retArr);
+					case 'DebuggerStatement':
+						return this.astDebuggerStatement(ast, retArr);
+				}
+
+				throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast);
+			}
+		}
+
+	}, {
+		key: 'astErrorOutput',
+		value: function astErrorOutput(error, ast) {
+			console.error(utils.getAstString(this.jsFunctionString, ast));
+			console.error(error, ast, this);
+			return error;
+		}
+	}, {
+		key: 'astDebuggerStatement',
+		value: function astDebuggerStatement(arrNode, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astFunctionDeclaration',
+		value: function astFunctionDeclaration(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astFunctionExpression',
+		value: function astFunctionExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astReturnStatement',
+		value: function astReturnStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astLiteral',
+		value: function astLiteral(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astBinaryExpression',
+		value: function astBinaryExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astAssignmentExpression',
+		value: function astAssignmentExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astExpressionStatement',
+		value: function astExpressionStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astEmptyStatement',
+		value: function astEmptyStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astBlockStatement',
+		value: function astBlockStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astIfStatement',
+		value: function astIfStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astBreakStatement',
+		value: function astBreakStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astContinueStatement',
+		value: function astContinueStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astForStatement',
+		value: function astForStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astWhileStatement',
+		value: function astWhileStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astDoWhileStatement',
+		value: function astDoWhileStatement(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astVariableDeclaration',
+		value: function astVariableDeclaration(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astVariableDeclarator',
+		value: function astVariableDeclarator(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astThisExpression',
+		value: function astThisExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astSequenceExpression',
+		value: function astSequenceExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astUnaryExpression',
+		value: function astUnaryExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astUpdateExpression',
+		value: function astUpdateExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astLogicalExpression',
+		value: function astLogicalExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astMemberExpression',
+		value: function astMemberExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astCallExpression',
+		value: function astCallExpression(ast, retArr) {
+			return retArr;
+		}
+	}, {
+		key: 'astArrayExpression',
+		value: function astArrayExpression(ast, retArr) {
+			return retArr;
+		}
+
+
+	}, {
+		key: 'pushParameter',
+		value: function pushParameter(retArr, parameter) {
+			if (this.isState('in-get-call-parameters')) {
+				retArr.push('int(' + parameter + ')');
+			} else {
+				retArr.push(parameter);
+			}
+		}
+	}, {
+		key: 'state',
+		get: function get() {
+			return this.states[this.states.length - 1];
+		}
+	}]);
+
+	return BaseFunctionNode;
+}();
+},{"../core/utils":32,"acorn":34}],8:[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');
+var Input = require('../core/input');
+
+module.exports = function () {
+
+	function KernelBase(fnString, settings) {
+		_classCallCheck(this, KernelBase);
+
+		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.outputImmutable = 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.subKernels = null;
+		this.subKernelProperties = null;
+		this.subKernelNames = null;
+		this.subKernelOutputVariableNames = null;
+		this.functionBuilder = null;
+		this.paramTypes = null;
+		this.paramSizes = null;
+		this.constantTypes = null;
+		this.fixIntegerDivisionAccuracy = null;
+		this.constrainStart = null;
+		this.constrainEnd = 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;
+		}
+		if (settings.hasOwnProperty('webGl')) {
+			this._webGl = settings.webGl;
+		}
+		if (settings.hasOwnProperty('output')) {
+			this.setOutput(settings.output); 
+		}
+
+		if (!this._canvas) this._canvas = utils.initCanvas();
+	}
+
+	_createClass(KernelBase, [{
+		key: 'build',
+		value: function build() {
+			throw new Error('"build" not defined on Base');
+		}
+
+
+	}, {
+		key: 'setupParams',
+		value: function setupParams(args) {
+			this.paramTypes = [];
+			this.paramSizes = [];
+			for (var i = 0; i < args.length; i++) {
+				var arg = args[i];
+
+				this.paramTypes.push(utils.getArgumentType(arg));
+				this.paramSizes.push(arg.constructor === Input ? arg.size : null);
+			}
+		}
+	}, {
+		key: 'setupConstants',
+		value: function setupConstants() {
+			this.constantTypes = {};
+			if (this.constants) {
+				for (var p in this.constants) {
+					this.constantTypes[p] = utils.getArgumentType(this.constants[p]);
+				}
+			}
+		}
+	}, {
+		key: 'setFunctions',
+		value: function setFunctions(functions) {
+			this.functions = functions;
+			return this;
+		}
+
+
+	}, {
+		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;
+		}
+
+
+	}, {
+		key: 'setDebug',
+		value: function setDebug(flag) {
+			this.debug = flag;
+			return this;
+		}
+
+
+	}, {
+		key: 'setGraphical',
+		value: function setGraphical(flag) {
+			this.graphical = flag;
+			return this;
+		}
+
+
+	}, {
+		key: 'constrain',
+		value: function constrain(start, end) {
+			this.constrainStart = start || null;
+			this.constrainEnd = end || null;
+			return this;
+		}
+
+
+	}, {
+		key: 'deconstrain',
+		value: function deconstrain() {
+			this.constrainStart = null;
+			this.constrainEnd = null;
+			return this;
+		}
+
+
+	}, {
+		key: 'setLoopMaxIterations',
+		value: function setLoopMaxIterations(max) {
+			this.loopMaxIterations = max;
+			return this;
+		}
+
+
+	}, {
+		key: 'setFixIntegerDivisionAccuracy',
+		value: function setFixIntegerDivisionAccuracy(fix) {
+			this.fixIntegerDivisionAccuracy = fix;
+			return this;
+		}
+
+
+	}, {
+		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;
+		}
+	}, {
+		key: 'setOutputImmutable',
+		value: function setOutputImmutable(flag) {
+			this.outputImmutable = flag;
+			return this;
+		}
+
+
+	}, {
+		key: 'setFloatTextures',
+		value: function setFloatTextures(flag) {
+			this.floatTextures = flag;
+			return this;
+		}
+
+
+	}, {
+		key: 'setFloatOutput',
+		value: function setFloatOutput(flag) {
+			this.floatOutput = flag;
+			return this;
+		}
+	}, {
+		key: 'setFloatOutputForce',
+		value: function setFloatOutputForce(flag) {
+			this.floatOutputForce = flag;
+			return this;
+		}
+
+
+	}, {
+		key: 'setCanvas',
+		value: function setCanvas(canvas) {
+			this._canvas = canvas;
+			return this;
+		}
+
+
+	}, {
+		key: 'setWebGl',
+		value: function setWebGl(webGl) {
+			this._webGl = webGl;
+			return this;
+		}
+
+
+	}, {
+		key: 'getCanvas',
+		value: function getCanvas() {
+			return this._canvas;
+		}
+
+
+	}, {
+		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;
+
+			var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+
+			return utils.newPromise(function (accept, reject) {
+				try {
+					accept(_this.run.apply(_this, args));
+				} catch (e) {
+					reject(e);
+				}
+			});
+		}
+
+
+	}, {
+		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;
+		}
+
+
+	}, {
+		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);
+		}
+
+
+	}, {
+		key: 'destroy',
+		value: function destroy() {}
+	}]);
+
+	return KernelBase;
+}();
+},{"../core/input":29,"../core/utils":32}],9:[function(require,module,exports){
+'use strict';
+
+var utils = require('../core/utils');
+
+module.exports = function kernelRunShortcut(kernel) {
+	var shortcut = function shortcut() {
+		return kernel.run.apply(kernel, arguments);
+	};
+
+	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;
+			});
+		}
+	});
+
+	shortcut.kernel = kernel;
+
+	return shortcut;
+};
+},{"../core/utils":32}],10:[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');
+var kernelRunShortcut = require('./kernel-run-shortcut');
+
+module.exports = function () {
+
+
+	function BaseRunner(functionBuilder, settings) {
+		_classCallCheck(this, BaseRunner);
+
+		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();
+	}
+
+
+
+	_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];
+			});
+
+			return copy(texture);
+		}
+
+
+	}, {
+		key: 'deleteTexture',
+		value: function deleteTexture(texture) {
+			this.webGl.deleteTexture(texture.texture);
+		}
+
+
+	}, {
+		key: 'buildPromiseKernel',
+		value: function buildPromiseKernel() {
+			throw new Error('not yet implemented');
+		}
+	}, {
+		key: 'getMode',
+		value: function getMode() {
+			throw new Error('"mode" not implemented on BaseRunner');
+		}
+
+
+	}, {
+		key: 'buildKernel',
+		value: function buildKernel(fn, settings) {
+			settings = Object.assign({}, settings || {});
+			var fnString = fn.toString();
+			if (!settings.functionBuilder) {
+				settings.functionBuilder = this.functionBuilder;
+			}
+
+			if (!settings.canvas) {
+				settings.canvas = this.canvas;
+			}
+
+			if (!settings.webGl) {
+				settings.webGl = this.webgl;
+			}
+
+			return kernelRunShortcut(new this.Kernel(fnString, settings));
+		}
+	}]);
+
+	return BaseRunner;
+}();
+},{"../core/utils":32,"./kernel-run-shortcut":9}],11:[function(require,module,exports){
+'use strict';
+
+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 FunctionBuilderBase = require('../function-builder-base');
+var WebGL2FunctionNode = require('./function-node');
+
+module.exports = function (_FunctionBuilderBase) {
+  _inherits(WebGL2FunctionBuilder, _FunctionBuilderBase);
+
+  function WebGL2FunctionBuilder() {
+    _classCallCheck(this, WebGL2FunctionBuilder);
+
+    var _this = _possibleConstructorReturn(this, (WebGL2FunctionBuilder.__proto__ || Object.getPrototypeOf(WebGL2FunctionBuilder)).call(this));
+
+    _this.Node = WebGL2FunctionNode;
+    return _this;
+  }
+
+  return WebGL2FunctionBuilder;
+}(FunctionBuilderBase);
+},{"../function-builder-base":6,"./function-node":12}],12:[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"); } }
+
+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 WebGLFunctionNode = require('../web-gl/function-node');
+var DECODE32_ENCODE32 = /decode32\(\s+encode32\(/g;
+var ENCODE32_DECODE32 = /encode32\(\s+decode32\(/g;
+
+module.exports = function (_WebGLFunctionNode) {
+	_inherits(WebGL2FunctionNode, _WebGLFunctionNode);
+
+	function WebGL2FunctionNode() {
+		_classCallCheck(this, WebGL2FunctionNode);
+
+		return _possibleConstructorReturn(this, (WebGL2FunctionNode.__proto__ || Object.getPrototypeOf(WebGL2FunctionNode)).apply(this, arguments));
+	}
+
+	_createClass(WebGL2FunctionNode, [{
+		key: 'generate',
+		value: function generate() {
+			if (this.debug) {
+				console.log(this);
+			}
+			if (this.prototypeOnly) {
+				return this.astFunctionPrototype(this.getJsAST(), []).join('').trim();
+			} else {
+				this.functionStringArray = this.astGeneric(this.getJsAST(), []);
+			}
+			this.functionString = webGlRegexOptimize(this.functionStringArray.join('').trim());
+			return this.functionString;
+		}
+
+
+	}, {
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(idtNode, retArr) {
+			if (idtNode.type !== 'Identifier') {
+				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode);
+			}
+
+			var castFloat = !this.isState('in-get-call-parameters');
+
+			switch (idtNode.name) {
+				case 'gpu_threadX':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.x');
+					castFloat && retArr.push(')');
+					break;
+				case 'gpu_threadY':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.y');
+					castFloat && retArr.push(')');
+					break;
+				case 'gpu_threadZ':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.z');
+					castFloat && retArr.push(')');
+					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;
+				case 'Infinity':
+					retArr.push('intBitsToFloat(2139095039)');
+					break;
+				default:
+					var userParamName = this.getUserParamName(idtNode.name);
+					if (userParamName !== null) {
+						this.pushParameter(retArr, 'user_' + userParamName);
+					} else {
+						this.pushParameter(retArr, 'user_' + idtNode.name);
+					}
+			}
+
+			return retArr;
+		}
+	}]);
+
+	return WebGL2FunctionNode;
+}(WebGLFunctionNode);
+
+function webGlRegexOptimize(inStr) {
+	return inStr.replace(DECODE32_ENCODE32, '((').replace(ENCODE32_DECODE32, '((');
+}
+},{"../web-gl/function-node":19}],13:[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"); } }
+
+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 WebGLKernel = require('../web-gl/kernel');
+var utils = require('../../core/utils');
+var Texture = require('../../core/texture');
+var fragShaderString = require('./shader-frag');
+var vertShaderString = require('./shader-vert');
+
+module.exports = function (_WebGLKernel) {
+	_inherits(WebGL2Kernel, _WebGLKernel);
+
+	function WebGL2Kernel() {
+		_classCallCheck(this, WebGL2Kernel);
+
+		return _possibleConstructorReturn(this, (WebGL2Kernel.__proto__ || Object.getPrototypeOf(WebGL2Kernel)).apply(this, arguments));
+	}
+
+	_createClass(WebGL2Kernel, [{
+		key: 'initWebGl',
+		value: function initWebGl() {
+			return utils.initWebGl2(this.getCanvas());
+		}
+
+	}, {
+		key: 'validateOptions',
+		value: function validateOptions() {
+			var isFloatReadPixel = utils.isFloatReadPixelsSupportedWebGL2();
+			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) {
+				this.floatTextures = true;
+				this.floatOutput = isFloatReadPixel;
+			}
+
+			var hasIntegerDivisionBug = utils.hasIntegerDivisionAccuracyBug();
+			if (this.fixIntegerDivisionAccuracy === null) {
+				this.fixIntegerDivisionAccuracy = hasIntegerDivisionBug;
+			} else if (this.fixIntegerDivisionAccuracy && !hasIntegerDivisionBug) {
+				this.fixIntegerDivisionAccuracy = false;
+			}
+
+			utils.checkOutput(this.output);
+
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw new Error('Auto output 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 === 'NumberTexture' || argType === 'ArrayTexture(4)') {
+					this.output = arguments[0].output;
+				} else {
+					throw new Error('Auto output not supported for input type: ' + argType);
+				}
+			}
+
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+
+			if (this.graphical) {
+				if (this.output.length !== 2) {
+					throw new Error('Output must have 2 dimensions on graphical mode');
+				}
+
+				if (this.floatOutput) {
+					this.floatOutput = false;
+					console.warn('Cannot use graphical mode and float output at the same time');
+				}
+
+				this.texSize = utils.clone(this.output);
+			} else if (this.floatOutput === undefined) {
+				this.floatOutput = true;
+			}
+
+			if (this.floatOutput || this.floatOutputForce) {
+				this._webGl.getExtension('EXT_color_buffer_float');
+			}
+		}
+
+
+	}, {
+		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) {
+				this.setUniform3iv('uOutputDim', new Int32Array(this.threadDim));
+				this.setUniform2iv('uTexSize', texSize);
+			}
+
+			this.setUniform2f('ratio', 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.constrainStart || this.constrainEnd) {
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+				if (this.constrainStart) {} else {}
+				if (this.constrainEnd) {} else {}
+				var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.5, 0.5, 0.0];
+
+				var indices = [3, 2, 1, 3, 1, 0];
+
+				var vertex_buffer = gl.createBuffer();
+
+				gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+				gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+				var Index_Buffer = gl.createBuffer();
+
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+				gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLES, 0, 6);
+				return;
+			}
+
+			if (this.graphical) {
+				if (this.outputToTexture) {
+					gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+					gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+					if (!this.outputTexture || this.outputImmutable) {
+						this._setupOutputTexture();
+					}
+					gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+					return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this._webGl, 'ArrayTexture(4)');
+				}
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+				return;
+			}
+
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+			if (this.outputImmutable) {
+				this._setupOutputTexture();
+			}
+			var outputTexture = this.outputTexture;
+
+			if (this.subKernelOutputVariableNames !== null) {
+				if (this.outputImmutable) {
+					this.subKernelOutputTextures = [];
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+				gl.drawBuffers(this.drawBuffersMap);
+			}
+
+			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.threadDim, this.output, this._webGl));
+					}
+					return output;
+				} else if (this.subKernelProperties !== null) {
+					var _output = {
+						result: this.renderOutput(outputTexture)
+					};
+					var _i = 0;
+					for (var p in this.subKernelProperties) {
+						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+						_output[p] = new Texture(this.subKernelOutputTextures[_i], texSize, this.threadDim, this.output, this._webGl);
+						_i++;
+					}
+					return _output;
+				}
+			}
+
+			return this.renderOutput(outputTexture);
+		}
+
+
+	}, {
+		key: 'getOutputTexture',
+		value: function getOutputTexture() {
+			return this.outputTexture;
+		}
+
+
+	}, {
+		key: '_setupOutputTexture',
+		value: function _setupOutputTexture() {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var texture = this.outputTexture = this._webGl.createTexture();
+			gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length);
+			gl.bindTexture(gl.TEXTURE_2D, texture);
+			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.RGBA32F, 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);
+			}
+			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		}
+
+
+	}, {
+		key: '_setupSubOutputTextures',
+		value: function _setupSubOutputTextures(length) {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
+			var textures = this.subKernelOutputTextures = [];
+			for (var i = 0; i < length; i++) {
+				var texture = this._webGl.createTexture();
+				textures.push(texture);
+				drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
+				gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length + i);
+				gl.bindTexture(gl.TEXTURE_2D, texture);
+				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.RGBA32F, 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);
+				}
+				gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
+			}
+		}
+
+
+	}, {
+		key: '_addArgument',
+		value: function _addArgument(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength + 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 _formatArrayTransfer = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer.valuesFlat,
+						    bitRatio = _formatArrayTransfer.bitRatio;
+
+						var buffer = void 0;
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, 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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', dim);
+							this.setUniform2iv('user_' + name + 'Size', size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				case 'Number':
+					{
+						this.setUniform1f('user_' + name, 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.constantsLength + 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 _formatArrayTransfer2 = this._formatArrayTransfer(value.value, _length),
+						    _valuesFlat = _formatArrayTransfer2.valuesFlat,
+						    _bitRatio = _formatArrayTransfer2.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, _size[0], _size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer = new Uint8Array(_valuesFlat.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0] / _bitRatio, _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', _dim);
+							this.setUniform2iv('user_' + name + 'Size', _size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', _bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim2 = [inputImage.width, inputImage.height, 1];
+						var _size2 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var mipLevel = 0; 
+						var internalFormat = gl.RGBA; 
+						var srcFormat = gl.RGBA; 
+						var srcType = gl.UNSIGNED_BYTE; 
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('user_' + name + 'Dim', _dim2);
+						this.setUniform2iv('user_' + name + 'Size', _size2);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImageArray':
+					{
+						var inputImages = value;
+						var _dim3 = [inputImages[0].width, inputImages[0].height, inputImages.length];
+						var _size3 = [inputImages[0].width, inputImages[0].height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var _mipLevel = 0; 
+						var _internalFormat = gl.RGBA; 
+						var width = inputImages[0].width;
+						var height = inputImages[0].height;
+						var textureDepth = inputImages.length;
+						var border = 0;
+						var _srcFormat = gl.RGBA; 
+						var _srcType = gl.UNSIGNED_BYTE; 
+						gl.texImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel, _internalFormat, width, height, textureDepth, border, _srcFormat, _srcType, null);
+						for (var i = 0; i < inputImages.length; i++) {
+							var xOffset = 0;
+							var yOffset = 0;
+							var imageDepth = 1;
+							gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel, xOffset, yOffset, i, inputImages[i].width, inputImages[i].height, imageDepth, _srcFormat, _srcType, inputImages[i]);
+						}
+						this.setUniform3iv('user_' + name + 'Dim', _dim3);
+						this.setUniform2iv('user_' + name + 'Size', _size3);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim4 = inputTexture.dimensions;
+						var _size4 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('user_' + name + 'Dim', _dim4);
+						this.setUniform2iv('user_' + name + 'Size', _size4);
+						this.setUniform1i('user_' + name + 'BitRatio', 1); 
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+			this.argumentsLength++;
+		}
+
+
+	}, {
+		key: '_getMainConstantsString',
+		value: function _getMainConstantsString() {
+			var result = [];
+			if (this.constants) {
+				for (var name in this.constants) {
+					if (!this.constants.hasOwnProperty(name)) continue;
+					var value = this.constants[name];
+					var type = utils.getArgumentType(value);
+					switch (type) {
+						case 'Integer':
+							result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
+							break;
+						case 'Float':
+							result.push('const float constants_' + name + ' = ' + parseFloat(value));
+							break;
+						case 'Array':
+						case 'Input':
+						case 'HTMLImage':
+						case 'ArrayTexture(4)':
+						case 'NumberTexture':
+							result.push('uniform highp sampler2D constants_' + name, 'uniform highp ivec2 constants_' + name + 'Size', 'uniform highp ivec3 constants_' + name + 'Dim', 'uniform highp int constants_' + name + 'BitRatio');
+							break;
+						case 'HTMLImageArray':
+							result.push('uniform highp sampler2DArray constants_' + name, 'uniform highp ivec2 constants_' + name + 'Size', 'uniform highp ivec3 constants_' + name + 'Dim', 'uniform highp int constants_' + name + 'BitRatio');
+							break;
+
+						default:
+							throw new Error('Unsupported constant ' + name + ' type ' + type);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_addConstant',
+		value: function _addConstant(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength);
+						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 _formatArrayTransfer3 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer3.valuesFlat,
+						    bitRatio = _formatArrayTransfer3.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', dim);
+							this.setUniform2iv('constants_' + name + 'Size', size);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Input':
+					{
+						var input = value;
+						var _dim5 = input.size;
+						var _size5 = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, _dim5);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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 _length2 = _size5[0] * _size5[1];
+
+						var _formatArrayTransfer4 = this._formatArrayTransfer(value.value, _length2),
+						    _valuesFlat2 = _formatArrayTransfer4.valuesFlat,
+						    _bitRatio2 = _formatArrayTransfer4.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, _size5[0], _size5[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer2 = new Uint8Array(_valuesFlat2.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size5[0] / _bitRatio2, _size5[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer2);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', _dim5);
+							this.setUniform2iv('constants_' + name + 'Size', _size5);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', _bitRatio2);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim6 = [inputImage.width, inputImage.height, 1];
+						var _size6 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var mipLevel = 0; 
+						var internalFormat = gl.RGBA; 
+						var srcFormat = gl.RGBA; 
+						var srcType = gl.UNSIGNED_BYTE; 
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('constants_' + name + 'Dim', _dim6);
+						this.setUniform2iv('constants_' + name + 'Size', _size6);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImageArray':
+					{
+						var inputImages = value;
+						var _dim7 = [inputImages[0].width, inputImages[0].height, inputImages.length];
+						var _size7 = [inputImages[0].width, inputImages[0].height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var _mipLevel2 = 0; 
+						var _internalFormat2 = gl.RGBA; 
+						var width = inputImages[0].width;
+						var height = inputImages[0].height;
+						var textureDepth = inputImages.length;
+						var border = 0;
+						var _srcFormat2 = gl.RGBA; 
+						var _srcType2 = gl.UNSIGNED_BYTE; 
+						gl.texImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel2, _internalFormat2, width, height, textureDepth, border, _srcFormat2, _srcType2, null);
+						for (var i = 0; i < inputImages.length; i++) {
+							var xOffset = 0;
+							var yOffset = 0;
+							var imageDepth = 1;
+							gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel2, xOffset, yOffset, i, inputImages[i].width, inputImages[i].height, imageDepth, _srcFormat2, _srcType2, inputImages[i]);
+						}
+						this.setUniform3iv('constants_' + name + 'Dim', _dim7);
+						this.setUniform2iv('constants_' + name + 'Size', _size7);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim8 = inputTexture.dimensions;
+						var _size8 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('constants_' + name + 'Dim', _dim8);
+						this.setUniform2iv('constants_' + name + 'Size', _size8);
+						this.setUniform1i('constants_' + name + 'BitRatio', 1); 
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+		}
+
+
+	}, {
+		key: '_getGetResultString',
+		value: function _getGetResultString() {
+			if (!this.floatTextures) {
+				return '  return decode(texel, x, bitRatio);';
+			}
+			return '  return texel[channel];';
+		}
+
+
+	}, {
+		key: '_getHeaderString',
+		value: function _getHeaderString() {
+			return '';
+		}
+
+
+	}, {
+		key: '_getTextureCoordinate',
+		value: function _getTextureCoordinate() {
+			var names = this.subKernelOutputVariableNames;
+			if (names === null || names.length < 1) {
+				return 'in highp vec2 vTexCoord;\n';
+			} else {
+				return 'out highp vec2 vTexCoord;\n';
+			}
+		}
+
+
+	}, {
+		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 === 'NumberTexture' || paramType === 'ArrayTexture(4)') {
+						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 ivec2 user_' + paramName + 'Size = ivec2(' + paramSize[0] + ', ' + paramSize[1] + ')', 'highp ivec3 user_' + paramName + 'Dim = ivec3(' + paramDim[0] + ', ' + paramDim[1] + ', ' + paramDim[2] + ')', 'uniform highp int user_' + paramName + 'BitRatio');
+					} else if (paramType === 'Integer') {
+						result.push('highp float user_' + paramName + ' = ' + param + '.0');
+					} else if (paramType === 'Float') {
+						result.push('highp float user_' + paramName + ' = ' + param);
+					}
+				} else {
+					if (paramType === 'Array' || paramType === 'NumberTexture' || paramType === 'ArrayTexture(4)' || paramType === 'Input' || paramType === 'HTMLImage') {
+						result.push('uniform highp sampler2D user_' + paramName, 'uniform highp ivec2 user_' + paramName + 'Size', 'uniform highp ivec3 user_' + paramName + 'Dim');
+						if (paramType !== 'HTMLImage') {
+							result.push('uniform highp int user_' + paramName + 'BitRatio');
+						}
+					} else if (paramType === 'HTMLImageArray') {
+						result.push('uniform highp sampler2DArray user_' + paramName, 'uniform highp ivec2 user_' + paramName + 'Size', 'uniform highp ivec3 user_' + paramName + 'Dim');
+					} else if (paramType === 'Integer' || paramType === 'Float') {
+						result.push('uniform float user_' + paramName);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_getKernelString',
+		value: function _getKernelString() {
+			var result = [];
+			var names = this.subKernelOutputVariableNames;
+			if (names !== null) {
+				result.push('float kernelResult = 0.0');
+				result.push('layout(location = 0) out vec4 data0');
+				for (var i = 0; i < names.length; i++) {
+					result.push('float ' + names[i] + ' = 0.0', 'layout(location = ' + (i + 1) + ') out vec4 data' + (i + 1));
+				}
+			} else {
+				result.push('out vec4 data0');
+				result.push('float kernelResult = 0.0');
+			}
+
+			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+		}
+
+
+	}, {
+		key: '_getMainResultString',
+		value: function _getMainResultString() {
+			var names = this.subKernelOutputVariableNames;
+			var result = [];
+
+			if (this.floatOutput) {
+				result.push('  index *= 4');
+			}
+
+			if (this.graphical) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  data0 = actualColor');
+			} else if (this.floatOutput) {
+				var channels = ['r', 'g', 'b', 'a'];
+
+				for (var i = 0; i < channels.length; ++i) {
+					result.push('  threadId = indexTo3D(index, uOutputDim)');
+					result.push('  kernel()');
+
+					if (names) {
+						result.push('  data0.' + channels[i] + ' = kernelResult');
+
+						for (var j = 0; j < names.length; ++j) {
+							result.push('  data' + (j + 1) + '.' + channels[i] + ' = ' + names[j]);
+						}
+					} else {
+						result.push('  data0.' + channels[i] + ' = kernelResult');
+					}
+
+					if (i < channels.length - 1) {
+						result.push('  index += 1');
+					}
+				}
+			} else if (names !== null) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)');
+				result.push('  kernel()');
+				result.push('  data0 = encode32(kernelResult)');
+				for (var _i2 = 0; _i2 < names.length; _i2++) {
+					result.push('  data' + (_i2 + 1) + ' = encode32(' + names[_i2] + ')');
+				}
+			} else {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  data0 = encode32(kernelResult)');
+			}
+
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_addKernels',
+		value: function _addKernels() {
+			var _this2 = this;
+
+			var builder = this.functionBuilder;
+			var gl = this._webGl;
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+			builder.addNativeFunctions(this.nativeFunctions);
+
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				paramNames: this.paramNames,
+				paramTypes: this.paramTypes,
+				constantTypes: this.constantTypes,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+
+			if (this.subKernels !== null) {
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				this.subKernels.forEach(function (subKernel) {
+					return _this2._addSubKernel(subKernel);
+				});
+			} else if (this.subKernelProperties !== null) {
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				Object.keys(this.subKernelProperties).forEach(function (property) {
+					return _this2._addSubKernel(_this2.subKernelProperties[property]);
+				});
+			}
+		}
+
+
+	}, {
+		key: '_getFragShaderString',
+		value: function _getFragShaderString(args) {
+			if (this.compiledFragShaderString !== null) {
+				return this.compiledFragShaderString;
+			}
+			return this.compiledFragShaderString = this._replaceArtifacts(this.constructor.fragShaderString, this._getFragShaderArtifactMap(args));
+		}
+
+
+	}, {
+		key: '_getVertShaderString',
+		value: function _getVertShaderString(args) {
+			if (this.compiledVertShaderString !== null) {
+				return this.compiledVertShaderString;
+			}
+			return this.compiledVertShaderString = this.constructor.vertShaderString;
+		}
+	}], [{
+		key: 'fragShaderString',
+		get: function get() {
+			return fragShaderString;
+		}
+	}, {
+		key: 'vertShaderString',
+		get: function get() {
+			return vertShaderString;
+		}
+	}]);
+
+	return WebGL2Kernel;
+}(WebGLKernel);
+},{"../../core/texture":30,"../../core/utils":32,"../web-gl/kernel":21,"./shader-frag":15,"./shader-vert":16}],14:[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"); } }
+
+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 RunnerBase = require('../runner-base');
+var WebGL2FunctionBuilder = require('./function-builder');
+var WebGL2Kernel = require('./kernel');
+
+module.exports = function (_RunnerBase) {
+	_inherits(WebGL2Runner, _RunnerBase);
+
+	function WebGL2Runner(settings) {
+		_classCallCheck(this, WebGL2Runner);
+
+		var _this = _possibleConstructorReturn(this, (WebGL2Runner.__proto__ || Object.getPrototypeOf(WebGL2Runner)).call(this, new WebGL2FunctionBuilder(), settings));
+
+		_this.Kernel = WebGL2Kernel;
+		_this.kernel = null;
+		return _this;
+	}
+
+
+
+	_createClass(WebGL2Runner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'gpu';
+		}
+	}]);
+
+	return WebGL2Runner;
+}(RunnerBase);
+},{"../runner-base":10,"./function-builder":11,"./kernel":13}],15:[function(require,module,exports){
+"use strict";
+
+module.exports = "#version 300 es\n__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n\n__CONSTANTS__;\n\nin vec2 vTexCoord;\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\nfloat integerMod(float x, float y) {\n  float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nint integerMod(int x, int y) {\n  return x - (y * int(x/y));\n}\n\n__DIVIDE_WITH_INTEGER_CHECK__;\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\nfloat decode32(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\nvec4 encode32(float f) {\n  float F = abs(f);\n  float sign = f < 0.0 ? 1.0 : 0.0;\n  float exponent = floor(log2(F));\n  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\nfloat decode(vec4 rgba, int x, int bitRatio) {\n  if (bitRatio == 1) {\n    return decode32(rgba);\n  }\n  __DECODE32_ENDIANNESS__;\n  int channel = integerMod(x, bitRatio);\n  if (bitRatio == 4) {\n    return rgba[channel] * 255.0;\n  }\n  else {\n    return rgba[channel*2] * 255.0 + rgba[channel*2 + 1] * 65280.0;\n  }\n}\n\nint index;\nivec3 threadId;\n\nivec3 indexTo3D(int idx, ivec3 texDim) {\n  int z = int(idx / (texDim.x * texDim.y));\n  idx -= z * int(texDim.x * texDim.y);\n  int y = int(idx / texDim.x);\n  int x = int(integerMod(idx, texDim.x));\n  return ivec3(x, y, z);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio,  int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  vec4 texel = texture(tex, st / vec2(texSize));\n  __GET_RESULT__;\n  \n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture(tex, st / vec2(texSize));\n}\n\nvec4 getImage3D(sampler2DArray tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture(tex, vec3(st / vec2(texSize), z));\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int y, int x) {\n  return get(tex, texSize, texDim, bitRatio, 0, y, x);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int x) {\n  return get(tex, texSize, texDim, bitRatio, 0, 0, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int y, int x) {\n  return getImage2D(tex, texSize, texDim, 0, y, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int x) {\n  return getImage2D(tex, texSize, texDim, 0, 0, x);\n}\n\nvec4 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 = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
+},{}],16:[function(require,module,exports){
+"use strict";
+
+module.exports = "#version 300 es\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nin vec2 aPos;\nin vec2 aTexCoord;\n\nout 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}";
+},{}],17:[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"); } }
+
+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 WebGLKernel = require('./kernel');
+var utils = require('../../core/utils');
+
+module.exports = function (_WebGLKernel) {
+	_inherits(WebGL2ValidatorKernel, _WebGLKernel);
+
+	function WebGL2ValidatorKernel() {
+		_classCallCheck(this, WebGL2ValidatorKernel);
+
+		return _possibleConstructorReturn(this, (WebGL2ValidatorKernel.__proto__ || Object.getPrototypeOf(WebGL2ValidatorKernel)).apply(this, arguments));
+	}
+
+	_createClass(WebGL2ValidatorKernel, [{
+		key: 'validateOptions',
+
+
+		value: function validateOptions() {
+			this._webGl.getExtension('EXT_color_buffer_float');
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+		}
+	}]);
+
+	return WebGL2ValidatorKernel;
+}(WebGLKernel);
+},{"../../core/utils":32,"./kernel":13}],18:[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"); } }
+
+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 FunctionBuilderBase = require('../function-builder-base');
+var WebGLFunctionNode = require('./function-node');
+
+module.exports = function (_FunctionBuilderBase) {
+	_inherits(WebGLFunctionBuilder, _FunctionBuilderBase);
+
+	function WebGLFunctionBuilder() {
+		_classCallCheck(this, WebGLFunctionBuilder);
+
+		var _this = _possibleConstructorReturn(this, (WebGLFunctionBuilder.__proto__ || Object.getPrototypeOf(WebGLFunctionBuilder)).call(this));
+
+		_this.Node = WebGLFunctionNode;
+		return _this;
+	}
+
+
+
+
+	_createClass(WebGLFunctionBuilder, [{
+		key: 'polyfillStandardFunctions',
+
+
+		value: function polyfillStandardFunctions() {
+			this.addFunction('round', _round);
+		}
+	}], [{
+		key: 'round',
+		value: function round(a) {
+			return _round(a);
+		}
+	}]);
+
+	return WebGLFunctionBuilder;
+}(FunctionBuilderBase);
+
+function _round(a) {
+	return Math.floor(a + 0.5);
+}
+},{"../function-builder-base":6,"./function-node":19}],19:[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"); } }
+
+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 FunctionNodeBase = require('../function-node-base');
+var utils = require('../../core/utils');
+var jsMathPrefix = 'Math.';
+var localPrefix = 'this.';
+var constantsPrefix = 'this.constants.';
+
+var DECODE32_ENCODE32 = /decode32\(\s+encode32\(/g;
+var ENCODE32_DECODE32 = /encode32\(\s+decode32\(/g;
+
+var debugLog = function debugLog() {};
+module.exports = function (_FunctionNodeBase) {
+	_inherits(WebGLFunctionNode, _FunctionNodeBase);
+
+	function WebGLFunctionNode() {
+		_classCallCheck(this, WebGLFunctionNode);
+
+		return _possibleConstructorReturn(this, (WebGLFunctionNode.__proto__ || Object.getPrototypeOf(WebGLFunctionNode)).apply(this, arguments));
+	}
+
+	_createClass(WebGLFunctionNode, [{
+		key: 'generate',
+		value: function generate() {
+			if (this.debug) {
+				debugLog(this);
+			}
+			if (this.prototypeOnly) {
+				return this.astFunctionPrototype(this.getJsAST(), []).join('').trim();
+			} else {
+				this.functionStringArray = this.astGeneric(this.getJsAST(), []);
+			}
+			this.functionString = webGlRegexOptimize(this.functionStringArray.join('').trim());
+			return this.functionString;
+		}
+
+
+	}, {
+		key: 'astFunctionDeclaration',
+		value: function astFunctionDeclaration(ast, retArr) {
+			this.builder.addFunction(null, utils.getAstString(this.jsFunctionString, ast));
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astFunctionPrototype',
+		value: function astFunctionPrototype(ast, retArr) {
+			if (this.isRootKernel || this.isSubKernel) {
+				return retArr;
+			}
+
+			var returnType = this.returnType;
+			var type = typeMap[returnType];
+			if (!type) {
+				throw new Error('unknown type ' + returnType);
+			}
+			retArr.push(type);
+			retArr.push(' ');
+			retArr.push(this.functionName);
+			retArr.push('(');
+
+			for (var i = 0; i < this.paramNames.length; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+
+				retArr.push(this.paramTypes[i]);
+				retArr.push(' ');
+				retArr.push('user_');
+				retArr.push(this.paramNames[i]);
+			}
+
+			retArr.push(');\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astFunctionExpression',
+		value: function astFunctionExpression(ast, retArr) {
+
+			if (this.isRootKernel) {
+				retArr.push('void');
+			} else {
+				var returnType = this.returnType;
+				var type = typeMap[returnType];
+				if (!type) {
+					throw new Error('unknown type ' + returnType);
+				}
+				retArr.push(type);
+			}
+			retArr.push(' ');
+			retArr.push(this.functionName);
+			retArr.push('(');
+
+			if (!this.isRootKernel) {
+				for (var i = 0; i < this.paramNames.length; ++i) {
+					var paramName = this.paramNames[i];
+
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					var paramType = this.getParamType(paramName);
+					var _type = typeMap[paramType];
+					if (!_type) {
+						throw new Error('unknown type ' + paramType);
+					}
+					retArr.push(_type);
+					retArr.push(' ');
+					retArr.push('user_');
+					retArr.push(paramName);
+				}
+			}
+
+			retArr.push(') {\n');
+
+			for (var _i = 0; _i < ast.body.body.length; ++_i) {
+				this.astGeneric(ast.body.body[_i], retArr);
+				retArr.push('\n');
+			}
+
+			retArr.push('}\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astReturnStatement',
+		value: function astReturnStatement(ast, retArr) {
+			if (this.isRootKernel) {
+				retArr.push('kernelResult = ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+				retArr.push('return;');
+			} else if (this.isSubKernel) {
+				retArr.push(this.functionName + 'Result = ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+				retArr.push('return ' + this.functionName + 'Result;');
+			} else {
+				retArr.push('return ');
+				this.astGeneric(ast.argument, retArr);
+				retArr.push(';');
+			}
+
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astLiteral',
+		value: function astLiteral(ast, retArr) {
+
+			if (isNaN(ast.value)) {
+				throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast);
+			}
+
+			retArr.push(ast.value);
+
+			var inGetParams = this.isState('in-get-call-parameters');
+			if (Number.isInteger(ast.value)) {
+				if (!inGetParams) {
+					retArr.push('.0');
+				}
+			} else if (inGetParams) {
+				retArr.pop();
+				retArr.push('int(');
+				retArr.push(ast.value);
+				retArr.push(')');
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBinaryExpression',
+		value: function astBinaryExpression(ast, retArr) {
+			var inGetParams = this.isState('in-get-call-parameters');
+			if (inGetParams) {
+				this.pushState('not-in-get-call-parameters');
+				retArr.push('int');
+			}
+			retArr.push('(');
+
+			if (ast.operator === '%') {
+				retArr.push('mod(');
+				this.astGeneric(ast.left, retArr);
+				retArr.push(',');
+				this.astGeneric(ast.right, retArr);
+				retArr.push(')');
+			} else if (ast.operator === '===') {
+				this.astGeneric(ast.left, retArr);
+				retArr.push('==');
+				this.astGeneric(ast.right, retArr);
+			} else if (ast.operator === '!==') {
+				this.astGeneric(ast.left, retArr);
+				retArr.push('!=');
+				this.astGeneric(ast.right, retArr);
+			} else if (this.fixIntegerDivisionAccuracy && ast.operator === '/') {
+				retArr.push('div_with_int_check(');
+				this.astGeneric(ast.left, retArr);
+				retArr.push(', ');
+				this.astGeneric(ast.right, retArr);
+				retArr.push(')');
+			} else {
+				this.astGeneric(ast.left, retArr);
+				retArr.push(ast.operator);
+				this.astGeneric(ast.right, retArr);
+			}
+
+			retArr.push(')');
+
+			if (inGetParams) {
+				this.popState('not-in-get-call-parameters');
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astIdentifierExpression',
+		value: function astIdentifierExpression(idtNode, retArr) {
+			if (idtNode.type !== 'Identifier') {
+				throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode);
+			}
+			var castFloat = !this.isState('in-get-call-parameters');
+
+			switch (idtNode.name) {
+				case 'gpu_threadX':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.x');
+					castFloat && retArr.push(')');
+					break;
+				case 'gpu_threadY':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.y');
+					castFloat && retArr.push(')');
+					break;
+				case 'gpu_threadZ':
+					castFloat && retArr.push('float(');
+					retArr.push('threadId.z');
+					castFloat && retArr.push(')');
+					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;
+				case 'Infinity':
+					retArr.push('3.402823466e+38');
+					break;
+				default:
+					var userParamName = this.getUserParamName(idtNode.name);
+					if (userParamName !== null) {
+						this.pushParameter(retArr, 'user_' + userParamName);
+					} else {
+						this.pushParameter(retArr, 'user_' + idtNode.name);
+					}
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astForStatement',
+		value: function astForStatement(forNode, retArr) {
+			if (forNode.type !== 'ForStatement') {
+				throw this.astErrorOutput('Invalid for statment', forNode);
+			}
+
+			if (forNode.test && forNode.test.type === 'BinaryExpression') {
+				if (forNode.test.right.type === 'Identifier' && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {
+
+					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.');
+					}
+
+					retArr.push('for (');
+					this.astGeneric(forNode.init, retArr);
+					this.astGeneric(forNode.test.left, retArr);
+					retArr.push(forNode.test.operator);
+					retArr.push('LOOP_MAX');
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr);
+					retArr.push(')');
+
+					retArr.push('{\n');
+					retArr.push('if (');
+					this.astGeneric(forNode.test.left, retArr);
+					retArr.push(forNode.test.operator);
+					this.astGeneric(forNode.test.right, retArr);
+					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);
+						}
+					} else {
+						this.astGeneric(forNode.body, retArr);
+					}
+					retArr.push('\n} else {\n');
+					retArr.push('break;\n');
+					retArr.push('}\n');
+					retArr.push('}\n');
+
+					return retArr;
+				} else {
+					var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));
+					var updateArgument = forNode.update.argument;
+					if (!Array.isArray(declarations) || declarations.length < 1) {
+						debugLog(this.jsFunctionString);
+						throw new Error('Error: Incompatible for loop declaration');
+					}
+
+					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);
+								retArr.push(';');
+							}
+						}
+
+						retArr.push('for (float ');
+						this.astGeneric(initArgument, retArr);
+						retArr.push(';');
+					} else {
+						retArr.push('for (');
+						this.astGeneric(forNode.init, retArr);
+					}
+
+					this.astGeneric(forNode.test, retArr);
+					retArr.push(';');
+					this.astGeneric(forNode.update, retArr);
+					retArr.push(')');
+					this.astGeneric(forNode.body, retArr);
+					return retArr;
+				}
+			}
+
+			throw this.astErrorOutput('Invalid for statement', forNode);
+		}
+
+
+	}, {
+		key: 'astWhileStatement',
+		value: function astWhileStatement(whileNode, retArr) {
+			if (whileNode.type !== 'WhileStatement') {
+				throw this.astErrorOutput('Invalid while statment', whileNode);
+			}
+
+			retArr.push('for (float i = 0.0; i < LOOP_MAX; i++) {');
+			retArr.push('if (');
+			this.astGeneric(whileNode.test, retArr);
+			retArr.push(') {\n');
+			this.astGeneric(whileNode.body, retArr);
+			retArr.push('} else {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astDoWhileStatement',
+		value: function astDoWhileStatement(doWhileNode, retArr) {
+			if (doWhileNode.type !== 'DoWhileStatement') {
+				throw this.astErrorOutput('Invalid while statment', doWhileNode);
+			}
+
+			retArr.push('for (float i = 0.0; i < LOOP_MAX; i++) {');
+			this.astGeneric(doWhileNode.body, retArr);
+			retArr.push('if (!');
+			this.astGeneric(doWhileNode.test, retArr);
+			retArr.push(') {\n');
+			retArr.push('break;\n');
+			retArr.push('}\n');
+			retArr.push('}\n');
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astAssignmentExpression',
+		value: function astAssignmentExpression(assNode, retArr) {
+			if (assNode.operator === '%=') {
+				this.astGeneric(assNode.left, retArr);
+				retArr.push('=');
+				retArr.push('mod(');
+				this.astGeneric(assNode.left, retArr);
+				retArr.push(',');
+				this.astGeneric(assNode.right, retArr);
+				retArr.push(')');
+			} else {
+				this.astGeneric(assNode.left, retArr);
+				retArr.push(assNode.operator);
+				this.astGeneric(assNode.right, retArr);
+				return retArr;
+			}
+		}
+
+
+	}, {
+		key: 'astEmptyStatement',
+		value: function astEmptyStatement(eNode, retArr) {
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBlockStatement',
+		value: function astBlockStatement(bNode, retArr) {
+			retArr.push('{\n');
+			for (var i = 0; i < bNode.body.length; i++) {
+				this.astGeneric(bNode.body[i], retArr);
+			}
+			retArr.push('}\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astExpressionStatement',
+		value: function astExpressionStatement(esNode, retArr) {
+			this.astGeneric(esNode.expression, retArr);
+			retArr.push(';');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astVariableDeclaration',
+		value: function astVariableDeclaration(vardecNode, retArr) {
+			for (var i = 0; i < vardecNode.declarations.length; i++) {
+				var declaration = vardecNode.declarations[i];
+				if (i > 0) {
+					retArr.push(',');
+				}
+				var retDeclaration = [];
+				this.astGeneric(declaration, retDeclaration);
+				var declarationType = 'Number';
+				if (i === 0) {
+					var init = declaration.init;
+					if (init) {
+						if (init.object) {
+							if (init.object.type === 'MemberExpression' && init.object.object) {
+								if (init.object.object.type === 'ThisExpression' && init.object.property && (init.object.property.name === 'thread' || init.object.property.name === 'output')) {
+									declarationType = 'Integer';
+								}
+								else if (init.object.object.type === 'Identifier') {
+										var _type2 = this.getParamType(init.object.object.name);
+										declarationType = typeLookupMap[_type2];
+									}
+									else if (init.object.object.object && init.object.object.object.type === 'Identifier') {
+											var _type3 = this.getParamType(init.object.object.object.name);
+											declarationType = typeLookupMap[_type3];
+										}
+										else if (init.object.object.object && init.object.object.object.object && init.object.object.object.object.type === 'ThisExpression' && init.object.object.object.property.name === 'constants') {
+												var _type4 = this.getConstantType(init.object.object.property.name);
+												declarationType = typeLookupMap[_type4];
+											}
+											else if (init.object.object.object && init.object.object.object.object && init.object.object.object.object.object && init.object.object.object.object.object.type === 'ThisExpression' && init.object.object.object.object.property.name === 'constants') {
+													var _type5 = this.getConstantType(init.object.object.object.property.name);
+													declarationType = typeLookupMap[_type5];
+												}
+							}
+							if (!declarationType) {
+								throw new Error('unknown lookup type ' + typeLookupMap);
+							}
+						} else {
+							if (init.name && this.declarations[init.name]) {
+								declarationType = this.declarations[init.name];
+							} else if (init.type === 'ArrayExpression') {
+								declarationType = 'Array(' + init.elements.length + ')';
+							} else if (init.type === 'CallExpression') {
+								var node = this.builder.nodeMap[init.callee.name];
+								if (node && node.returnType) {
+									declarationType = node.returnType;
+								}
+							}
+						}
+					}
+					var type = typeMap[declarationType];
+					if (!type) {
+						throw new Error('type ' + declarationType + ' not handled');
+					}
+					retArr.push(type + ' ');
+				}
+				this.declarations[declaration.id.name] = declarationType;
+				retArr.push.apply(retArr, retDeclaration);
+			}
+			retArr.push(';');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astVariableDeclarator',
+		value: function astVariableDeclarator(ivardecNode, retArr) {
+			this.astGeneric(ivardecNode.id, retArr);
+			if (ivardecNode.init !== null) {
+				retArr.push('=');
+				this.astGeneric(ivardecNode.init, retArr);
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astIfStatement',
+		value: function astIfStatement(ifNode, retArr) {
+			retArr.push('if (');
+			this.astGeneric(ifNode.test, retArr);
+			retArr.push(')');
+			if (ifNode.consequent.type === 'BlockStatement') {
+				this.astGeneric(ifNode.consequent, retArr);
+			} else {
+				retArr.push(' {\n');
+				this.astGeneric(ifNode.consequent, retArr);
+				retArr.push('\n}\n');
+			}
+
+			if (ifNode.alternate) {
+				retArr.push('else ');
+				if (ifNode.alternate.type === 'BlockStatement') {
+					this.astGeneric(ifNode.alternate, retArr);
+				} else {
+					retArr.push(' {\n');
+					this.astGeneric(ifNode.alternate, retArr);
+					retArr.push('\n}\n');
+				}
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astBreakStatement',
+		value: function astBreakStatement(brNode, retArr) {
+			retArr.push('break;\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astContinueStatement',
+		value: function astContinueStatement(crNode, retArr) {
+			retArr.push('continue;\n');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astLogicalExpression',
+		value: function astLogicalExpression(logNode, retArr) {
+			retArr.push('(');
+			this.astGeneric(logNode.left, retArr);
+			retArr.push(logNode.operator);
+			this.astGeneric(logNode.right, retArr);
+			retArr.push(')');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astUpdateExpression',
+		value: function astUpdateExpression(uNode, retArr) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr);
+			} else {
+				this.astGeneric(uNode.argument, retArr);
+				retArr.push(uNode.operator);
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astUnaryExpression',
+		value: function astUnaryExpression(uNode, retArr) {
+			if (uNode.prefix) {
+				retArr.push(uNode.operator);
+				this.astGeneric(uNode.argument, retArr);
+			} else {
+				this.astGeneric(uNode.argument, retArr);
+				retArr.push(uNode.operator);
+			}
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astThisExpression',
+		value: function astThisExpression(tNode, retArr) {
+			retArr.push('this');
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astMemberExpression',
+		value: function astMemberExpression(mNode, retArr) {
+			debugLog("[in] astMemberExpression " + mNode.object.type);
+			if (mNode.computed) {
+				if (mNode.object.type === 'Identifier' || mNode.object.type === 'MemberExpression' &&
+				mNode.object.object.object && mNode.object.object.object.type === 'ThisExpression' && mNode.object.object.property.name === 'constants') {
+					var reqName = mNode.object.name;
+					var funcName = this.functionName || 'kernel';
+					var assumeNotTexture = false;
+
+					if (this.paramNames) {
+						var idx = this.paramNames.indexOf(reqName);
+						if (idx >= 0 && this.paramTypes[idx] === 'Number') {
+							assumeNotTexture = true;
+						}
+					}
+					debugLog("- astMemberExpression " + reqName + " " + funcName);
+					if (assumeNotTexture) {
+						this.astGeneric(mNode.object, retArr);
+						retArr.push('[int(');
+						this.astGeneric(mNode.property, retArr);
+						retArr.push(')]');
+					} else {
+						var isInGetParams = this.isState('in-get-call-parameters');
+						var multiMemberExpression = this.isState('multi-member-expression');
+						if (multiMemberExpression) {
+							this.popState('multi-member-expression');
+						}
+						this.pushState('not-in-get-call-parameters');
+
+						var variableType = null;
+						if (mNode.object.name) {
+							if (this.declarations[mNode.object.name]) {
+								variableType = this.declarations[mNode.object.name];
+							} else {
+								variableType = this.getParamType(mNode.object.name);
+							}
+						} else if (mNode.object && mNode.object.object && mNode.object.object.object && mNode.object.object.object.type === 'ThisExpression') {
+							variableType = this.getConstantType(mNode.object.property.name);
+						}
+						switch (variableType) {
+							case 'Array(2)':
+							case 'Array(3)':
+							case 'Array(4)':
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('[');
+								retArr.push(mNode.property.raw);
+								retArr.push(']');
+								if (multiMemberExpression) {
+									this.popState('not-in-get-call-parameters');
+								}
+								break;
+							case 'HTMLImageArray':
+								retArr.push('getImage3D(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push(', ivec2(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[1]), ivec3(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[1],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[2]');
+								retArr.push('), ');
+								this.popState('not-in-get-call-parameters');
+								this.pushState('in-get-call-parameters');
+								this.astGeneric(mNode.property, retArr);
+								if (!multiMemberExpression) {
+									this.popState('in-get-call-parameters');
+								}
+								retArr.push(')');
+								break;
+							case 'ArrayTexture(4)':
+							case 'HTMLImage':
+								retArr.push('getImage2D(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push(', ivec2(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[1]), ivec3(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[1],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[2]');
+								retArr.push('), ');
+								this.popState('not-in-get-call-parameters');
+								this.pushState('in-get-call-parameters');
+								this.astGeneric(mNode.property, retArr);
+								if (!multiMemberExpression) {
+									this.popState('in-get-call-parameters');
+								}
+								retArr.push(')');
+								break;
+							default:
+								if (isInGetParams) {
+									retArr.push('int(');
+								}
+								retArr.push('get(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push(', ivec2(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Size[1]), ivec3(');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[0],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[1],');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('Dim[2]');
+								retArr.push('), ');
+								this.astGeneric(mNode.object, retArr);
+								retArr.push('BitRatio');
+								retArr.push(', ');
+								this.popState('not-in-get-call-parameters');
+								this.pushState('in-get-call-parameters');
+								this.astGeneric(mNode.property, retArr);
+								if (!multiMemberExpression) {
+									this.popState('in-get-call-parameters');
+								}
+								retArr.push(')');
+								if (isInGetParams) {
+									retArr.push(')');
+								}
+								break;
+						}
+					}
+				} else {
+
+					debugLog("- astMemberExpression obj:", mNode.object);
+					var stateStackDepth = this.states.length;
+					var startedInGetParamsState = this.isState('in-get-call-parameters');
+					if (!startedInGetParamsState) {
+						this.pushState('multi-member-expression');
+					}
+					this.astGeneric(mNode.object, retArr);
+					if (this.isState('multi-member-expression')) {
+						this.popState('multi-member-expression');
+					}
+					var changedGetParamsState = !startedInGetParamsState && this.isState('in-get-call-parameters');
+					var last = retArr.pop();
+					retArr.push(',');
+					debugLog("- astMemberExpression prop:", mNode.property);
+					var shouldPopParamState = this.isState('should-pop-in-get-call-parameters');
+					if (shouldPopParamState) {
+						this.popState('should-pop-in-get-call-parameters');
+					}
+					this.astGeneric(mNode.property, retArr);
+					retArr.push(last);
+
+					if (changedGetParamsState) {
+						this.pushState('should-pop-in-get-call-parameters');
+					} else if (shouldPopParamState) {
+						this.popState('in-get-call-parameters');
+					}
+				}
+			} else {
+
+				var unrolled = this.astMemberExpressionUnroll(mNode);
+				var unrolled_lc = unrolled.toLowerCase();
+				debugLog("- astMemberExpression unrolled:", unrolled);
+				if (unrolled.indexOf(constantsPrefix) === 0) {
+					unrolled = 'constants_' + unrolled.slice(constantsPrefix.length);
+				}
+
+				var castFloat = !this.isState('in-get-call-parameters');
+
+				switch (unrolled_lc) {
+					case 'this.thread.x':
+						castFloat && retArr.push('float(');
+						retArr.push('threadId.x');
+						castFloat && retArr.push(')');
+						break;
+					case 'this.thread.y':
+						castFloat && retArr.push('float(');
+						retArr.push('threadId.y');
+						castFloat && retArr.push(')');
+						break;
+					case 'this.thread.z':
+						castFloat && retArr.push('float(');
+						retArr.push('threadId.z');
+						castFloat && retArr.push(')');
+						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:
+						if (mNode.object && mNode.object.name && this.declarations[mNode.object.name]) {
+							retArr.push('user_');
+						}
+						retArr.push(unrolled);
+				}
+			}
+			debugLog("[out] astMemberExpression " + mNode.object.type);
+			return retArr;
+		}
+	}, {
+		key: 'astSequenceExpression',
+		value: function astSequenceExpression(sNode, retArr) {
+			for (var i = 0; i < sNode.expressions.length; i++) {
+				if (i > 0) {
+					retArr.push(',');
+				}
+				this.astGeneric(sNode.expressions, retArr);
+			}
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astCallExpression',
+		value: function astCallExpression(ast, retArr) {
+			if (ast.callee) {
+				var funcName = this.astMemberExpressionUnroll(ast.callee);
+
+				if (funcName.indexOf(jsMathPrefix) === 0) {
+					funcName = funcName.slice(jsMathPrefix.length);
+				}
+
+				if (funcName.indexOf(localPrefix) === 0) {
+					funcName = funcName.slice(localPrefix.length);
+				}
+
+				if (funcName === 'atan2') {
+					funcName = 'atan';
+				}
+
+				if (this.calledFunctions.indexOf(funcName) < 0) {
+					this.calledFunctions.push(funcName);
+				}
+				if (!this.hasOwnProperty('funcName')) {
+					this.calledFunctionsArguments[funcName] = [];
+				}
+
+				var functionArguments = [];
+				this.calledFunctionsArguments[funcName].push(functionArguments);
+
+				retArr.push(funcName);
+
+				retArr.push('(');
+
+				for (var i = 0; i < ast.arguments.length; ++i) {
+					var argument = ast.arguments[i];
+					if (i > 0) {
+						retArr.push(', ');
+					}
+					this.astGeneric(argument, retArr);
+					if (argument.type === 'Identifier') {
+						var paramIndex = this.paramNames.indexOf(argument.name);
+						if (paramIndex === -1) {
+							functionArguments.push(null);
+						} else {
+							functionArguments.push({
+								name: argument.name,
+								type: this.paramTypes[paramIndex] || 'Number'
+							});
+						}
+					} else {
+						functionArguments.push(null);
+					}
+				}
+
+				retArr.push(')');
+
+				return retArr;
+			}
+
+			throw this.astErrorOutput('Unknown CallExpression', ast);
+
+			return retArr;
+		}
+
+
+	}, {
+		key: 'astArrayExpression',
+		value: function astArrayExpression(arrNode, retArr) {
+			var arrLen = arrNode.elements.length;
+
+			retArr.push('vec' + arrLen + '(');
+			for (var i = 0; i < arrLen; ++i) {
+				if (i > 0) {
+					retArr.push(', ');
+				}
+				var subNode = arrNode.elements[i];
+				this.astGeneric(subNode, retArr);
+			}
+			retArr.push(')');
+
+			return retArr;
+
+		}
+
+
+	}, {
+		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;
+		}
+	}]);
+
+	return WebGLFunctionNode;
+}(FunctionNodeBase);
+
+var typeMap = {
+	'Array': 'sampler2D',
+	'Array(2)': 'vec2',
+	'Array(3)': 'vec3',
+	'Array(4)': 'vec4',
+	'Array2D': 'sampler2D',
+	'Array3D': 'sampler2D',
+	'Float': 'float',
+	'Input': 'sampler2D',
+	'Integer': 'float',
+	'Number': 'float',
+	'NumberTexture': 'sampler2D',
+	'ArrayTexture(4)': 'sampler2D'
+};
+
+var typeLookupMap = {
+	'Array': 'Number',
+	'Array2D': 'Number',
+	'Array3D': 'Number',
+	'HTMLImage': 'Array(4)',
+	'HTMLImageArray': 'Array(4)',
+	'NumberTexture': 'Number',
+	'ArrayTexture(4)': 'Array(4)'
+};
+
+function webGlRegexOptimize(inStr) {
+	return inStr.replace(DECODE32_ENCODE32, '((').replace(ENCODE32_DECODE32, '((');
+}
+},{"../../core/utils":32,"../function-node-base":7}],20:[function(require,module,exports){
+'use strict';
+
+var utils = require('../../core/utils');
+var kernelRunShortcut = require('../kernel-run-shortcut');
+var Input = require('../../core/input');
+var Texture = require('../../core/texture');
+
+function removeFnNoise(fn) {
+  if (/^function /.test(fn)) {
+    fn = fn.substring(9);
+  }
+  return fn.replace(/[_]typeof/g, 'typeof');
+}
+
+function removeNoise(str) {
+  return str.replace(/[_]typeof/g, 'typeof');
+}
+
+module.exports = function (gpuKernel, name) {
+  return '() => {\n    ' + kernelRunShortcut.toString() + ';\n    const utils = {\n      allPropertiesOf: ' + removeNoise(utils.allPropertiesOf.toString()) + ',\n      clone: ' + removeNoise(utils.clone.toString()) + ',\n      splitArray: ' + removeNoise(utils.splitArray.toString()) + ',\n      getArgumentType: ' + removeNoise(utils.getArgumentType.toString()) + ',\n      getDimensions: ' + removeNoise(utils.getDimensions.toString()) + ',\n      dimToTexSize: ' + removeNoise(utils.dimToTexSize.toString()) + ',\n      flattenTo: ' + removeNoise(utils.flattenTo.toString()) + ',\n      flatten2dArrayTo: ' + removeNoise(utils.flatten2dArrayTo.toString()) + ',\n      flatten3dArrayTo: ' + removeNoise(utils.flatten3dArrayTo.toString()) + ',\n      systemEndianness: \'' + removeNoise(utils.systemEndianness()) + '\',\n      initWebGl: ' + removeNoise(utils.initWebGl.toString()) + ',\n      isArray: ' + removeNoise(utils.isArray.toString()) + ',\n      checkOutput: ' + removeNoise(utils.checkOutput.toString()) + '\n    };\n    const Utils = utils;\n    const canvases = [];\n    const maxTexSizes = {};\n    let Texture = function() {};\n    let Input = function() {}; \n    class ' + (name || 'Kernel') + ' {\n      constructor() {\n        this.maxTexSize = null;\n        this.argumentsLength = 0;\n        this.constantsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.program = null;\n        this.outputToTexture = ' + (gpuKernel.outputToTexture ? 'true' : 'false') + ';\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\t\t    this.subKernelOutputVariableNames = null;\n\t\t    this.uniform1fCache = {};\n\t\t    this.uniform1iCache = {};\n\t\t    this.uniform2fCache = {};\n\t\t    this.uniform2fvCache = {};\n\t\t    this.uniform2ivCache = {};\n\t\t    this.uniform3fvCache = {};\n\t\t    this.uniform3ivCache = {};\n      }\n      _getFragShaderString() { return this.compiledFragShaderString; }\n      _getVertShaderString() { return this.compiledVertShaderString; }\n      validateOptions() {}\n      setupParams() {}\n      setupConstants() {}\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      setTexture(Type) { Texture = Type; }\n      setInput(Type) { Input = Type; }\n      ' + removeFnNoise(gpuKernel.getUniformLocation.toString()) + '\n      ' + removeFnNoise(gpuKernel.build.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.run.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel._addArgument.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel._formatArrayTransfer.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.getArgumentTexture.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.getTextureCache.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.getOutputTexture.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.renderOutput.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.updateMaxTexSize.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel._setupOutputTexture.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.detachTextureCache.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform1f.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform1i.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform2f.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform2fv.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform2iv.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform3fv.toString()) + '\n\t\t  ' + removeFnNoise(gpuKernel.setUniform3iv.toString()) + '\n    };\n    return kernelRunShortcut(new Kernel());\n  };';
+};
+},{"../../core/input":29,"../../core/texture":30,"../../core/utils":32,"../kernel-run-shortcut":9}],21:[function(require,module,exports){
+'use strict';
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+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 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 = {};
+
+module.exports = function (_KernelBase) {
+	_inherits(WebGLKernel, _KernelBase);
+
+	_createClass(WebGLKernel, null, [{
+		key: 'fragShaderString',
+		get: function get() {
+			return fragShaderString;
+		}
+	}, {
+		key: 'vertShaderString',
+		get: function get() {
+			return vertShaderString;
+		}
+
+	}]);
+
+	function WebGLKernel(fnString, settings) {
+		_classCallCheck(this, WebGLKernel);
+
+		var _this = _possibleConstructorReturn(this, (WebGLKernel.__proto__ || Object.getPrototypeOf(WebGLKernel)).call(this, fnString, settings));
+
+		_this.textureCache = {};
+		_this.threadDim = {};
+		_this.programUniformLocationCache = {};
+		_this.framebuffer = null;
+
+		_this.buffer = null;
+		_this.program = null;
+		_this.outputToTexture = settings.outputToTexture;
+		_this.endianness = utils.systemEndianness();
+		_this.subKernelOutputTextures = null;
+		_this.subKernelOutputVariableNames = null;
+		_this.argumentsLength = 0;
+		_this.constantsLength = 0;
+		_this.compiledFragShaderString = null;
+		_this.compiledVertShaderString = null;
+		_this.fragShader = null;
+		_this.vertShader = null;
+		_this.drawBuffersMap = null;
+		_this.outputTexture = null;
+		_this.maxTexSize = null;
+		_this.uniform1fCache = {};
+		_this.uniform1iCache = {};
+		_this.uniform2fCache = {};
+		_this.uniform2fvCache = {};
+		_this.uniform2ivCache = {};
+		_this.uniform3fvCache = {};
+		_this.uniform3ivCache = {};
+		if (!_this._webGl) _this._webGl = _this.initWebGl();
+		return _this;
+	}
+
+	_createClass(WebGLKernel, [{
+		key: 'initWebGl',
+		value: function initWebGl() {
+			return utils.initWebGl(this.getCanvas());
+		}
+
+
+	}, {
+		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;
+			}
+
+			var hasIntegerDivisionBug = utils.hasIntegerDivisionAccuracyBug();
+			if (this.fixIntegerDivisionAccuracy === null) {
+				this.fixIntegerDivisionAccuracy = hasIntegerDivisionBug;
+			} else if (this.fixIntegerDivisionAccuracy && !hasIntegerDivisionBug) {
+				this.fixIntegerDivisionAccuracy = false;
+			}
+
+			utils.checkOutput(this.output);
+
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw new Error('Auto output 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 === 'NumberTexture' || argType === 'ArrayTexture(4)') {
+					this.output = arguments[0].output;
+				} else {
+					throw new Error('Auto output not supported for input type: ' + argType);
+				}
+			}
+
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+
+			if (this.graphical) {
+				if (this.output.length !== 2) {
+					throw new Error('Output must have 2 dimensions on graphical mode');
+				}
+
+				if (this.floatOutput) {
+					this.floatOutput = false;
+					console.warn('Cannot use graphical mode and float output at the same time');
+				}
+
+				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];
+			}
+		}
+
+
+	}, {
+		key: 'build',
+		value: function build() {
+			this.validateOptions();
+			this.setupConstants();
+			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);
+			}
+
+			if (this.functionBuilder) this._addKernels();
+
+			var compiledVertShaderString = this._getVertShaderString(arguments);
+			var vertShader = gl.createShader(gl.VERTEX_SHADER);
+			gl.shaderSource(vertShader, compiledVertShaderString);
+			gl.compileShader(vertShader);
+			this.vertShader = vertShader;
+
+			var compiledFragShaderString = this._getFragShaderString(arguments);
+			var fragShader = gl.createShader(gl.FRAGMENT_SHADER);
+			gl.shaderSource(fragShader, compiledFragShaderString);
+			gl.compileShader(fragShader);
+			this.fragShader = fragShader;
+
+			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');
+			}
+
+			if (this.debug) {
+				console.log('Options:');
+				console.dir(this);
+				console.log('GLSL Shader Output:');
+				console.log(compiledFragShaderString);
+			}
+
+			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];
+
+			var vertices = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
+			var texCoords = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+
+			var texCoordOffset = vertices.byteLength;
+
+			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);
+			}
+
+			gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
+			gl.bufferSubData(gl.ARRAY_BUFFER, texCoordOffset, texCoords);
+
+			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);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+			for (var p in this.constants) {
+				var value = this.constants[p];
+				var type = utils.getArgumentType(value);
+				if (type === 'Float' || type === 'Integer') {
+					continue;
+				}
+				gl.useProgram(this.program);
+				this._addConstant(this.constants[p], type, p);
+				this.constantsLength++;
+			}
+
+			if (!this.outputImmutable) {
+				this._setupOutputTexture();
+				if (this.subKernelOutputVariableNames !== null && this.subKernelOutputVariableNames.length > 0) {
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+			}
+		}
+
+
+	}, {
+		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) {
+				this.setUniform3iv('uOutputDim', this.threadDim);
+				this.setUniform2iv('uTexSize', texSize);
+			}
+
+			this.setUniform2f('ratio', 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.constrainStart || this.constrainEnd) {
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+				if (this.constrainStart) {} else {}
+				if (this.constrainEnd) {} else {}
+				var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.5, 0.5, 0.0];
+
+				var indices = [3, 2, 1, 3, 1, 0];
+
+				var vertex_buffer = gl.createBuffer();
+
+				gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+				gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+				var Index_Buffer = gl.createBuffer();
+
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+				gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLES, 0, 6);
+				this._setupOutputTexture();
+				return this.renderOutput(this.outputTexture);
+			}
+
+			if (this.graphical) {
+				if (this.outputToTexture) {
+					gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+					gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+					if (!this.outputTexture || this.outputImmutable) {
+						this._setupOutputTexture();
+					}
+					gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+					return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this._webGl, 'ArrayTexture(4)');
+				}
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+				return;
+			}
+
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+			if (this.outputImmutable) {
+				this._setupOutputTexture();
+			}
+			var outputTexture = this.outputTexture;
+
+			if (this.subKernelOutputVariableNames !== null) {
+				if (this.outputImmutable) {
+					this.subKernelOutputTextures = [];
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+				this.drawBuffers.drawBuffersWEBGL(this.drawBuffersMap);
+			}
+
+			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.threadDim, this.output, this._webGl));
+					}
+					return output;
+				} else if (this.subKernelProperties !== null) {
+					var _output = {
+						result: this.renderOutput(outputTexture)
+					};
+					var _i = 0;
+					for (var p in this.subKernelProperties) {
+						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+						_output[p] = new Texture(this.subKernelOutputTextures[_i], texSize, this.threadDim, this.output, this._webGl);
+						_i++;
+					}
+					return _output;
+				}
+			}
+
+			return this.renderOutput(outputTexture);
+		}
+
+
+	}, {
+		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, this.threadDim, output, this._webGl);
+			} else {
+				var result = void 0;
+				if (this.floatOutput) {
+					var w = texSize[0];
+					var h = Math.ceil(texSize[1] / 4);
+					result = new Float32Array(w * h * 4);
+					gl.readPixels(0, 0, w, h, 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);
+				}
+
+				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]);
+					});
+				}
+			}
+		}
+
+
+	}, {
+		key: 'getOutputTexture',
+		value: function getOutputTexture() {
+			return this.outputTexture;
+		}
+
+
+	}, {
+		key: '_setupOutputTexture',
+		value: function _setupOutputTexture() {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var texture = this.outputTexture = this._webGl.createTexture();
+			gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length);
+			gl.bindTexture(gl.TEXTURE_2D, texture);
+			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);
+			}
+			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		}
+
+
+	}, {
+		key: '_setupSubOutputTextures',
+		value: function _setupSubOutputTextures(length) {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
+			var textures = this.subKernelOutputTextures = [];
+			for (var i = 0; i < length; i++) {
+				var texture = this._webGl.createTexture();
+				textures.push(texture);
+				drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
+				gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length + i);
+				gl.bindTexture(gl.TEXTURE_2D, texture);
+				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);
+				}
+				gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
+			}
+		}
+
+
+	}, {
+		key: 'getArgumentTexture',
+		value: function getArgumentTexture(name) {
+			return this.getTextureCache('ARGUMENT_' + name);
+		}
+
+
+	}, {
+		key: 'getTextureCache',
+		value: function getTextureCache(name) {
+			if (this.textureCache.hasOwnProperty(name)) {
+				return this.textureCache[name];
+			}
+			return this.textureCache[name] = this._webGl.createTexture();
+		}
+
+
+	}, {
+		key: 'detachTextureCache',
+		value: function detachTextureCache(name) {
+			delete this.textureCache[name];
+		}
+	}, {
+		key: 'setUniform1f',
+		value: function setUniform1f(name, value) {
+			if (this.uniform1fCache.hasOwnProperty(name)) {
+				var cache = this.uniform1fCache[name];
+				if (value === cache) {
+					return;
+				}
+			}
+			this.uniform1fCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform1f(loc, value);
+		}
+	}, {
+		key: 'setUniform1i',
+		value: function setUniform1i(name, value) {
+			if (this.uniform1iCache.hasOwnProperty(name)) {
+				var cache = this.uniform1iCache[name];
+				if (value === cache) {
+					return;
+				}
+			}
+			this.uniform1iCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform1i(loc, value);
+		}
+	}, {
+		key: 'setUniform2f',
+		value: function setUniform2f(name, value1, value2) {
+			if (this.uniform2fCache.hasOwnProperty(name)) {
+				var cache = this.uniform2fCache[name];
+				if (value1 === cache[0] && value2 === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2fCache[name] = [value1, value2];
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2f(loc, value1, value2);
+		}
+	}, {
+		key: 'setUniform2fv',
+		value: function setUniform2fv(name, value) {
+			if (this.uniform2fvCache.hasOwnProperty(name)) {
+				var cache = this.uniform2fvCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2fvCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2fv(loc, value);
+		}
+	}, {
+		key: 'setUniform2iv',
+		value: function setUniform2iv(name, value) {
+			if (this.uniform2ivCache.hasOwnProperty(name)) {
+				var cache = this.uniform2ivCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2ivCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2iv(loc, value);
+		}
+	}, {
+		key: 'setUniform3fv',
+		value: function setUniform3fv(name, value) {
+			if (this.uniform3fvCache.hasOwnProperty(name)) {
+				var cache = this.uniform3fvCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1] && value[2] === cache[2]) {
+					return;
+				}
+			}
+			this.uniform3fvCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform3fv(loc, value);
+		}
+	}, {
+		key: 'setUniform3iv',
+		value: function setUniform3iv(name, value) {
+			if (this.uniform3ivCache.hasOwnProperty(name)) {
+				var cache = this.uniform3ivCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1] && value[2] === cache[2]) {
+					return;
+				}
+			}
+			this.uniform3ivCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform3iv(loc, value);
+		}
+
+
+	}, {
+		key: 'getUniformLocation',
+		value: function getUniformLocation(name) {
+			if (this.programUniformLocationCache.hasOwnProperty(name)) {
+				return this.programUniformLocationCache[name];
+			}
+			return this.programUniformLocationCache[name] = this._webGl.getUniformLocation(this.program, name);
+		}
+
+
+	}, {
+		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(),
+				DIVIDE_WITH_INTEGER_CHECK: this._getDivideWithIntegerCheckString(),
+				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: '_addArgument',
+		value: function _addArgument(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			switch (type) {
+				case 'Array':
+				case 'Array(2)':
+				case 'Array(3)':
+				case 'Array(4)':
+				case 'Array2D':
+				case 'Array3D':
+					{
+						var dim = utils.getDimensions(value, true);
+						var size = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, dim);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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 _formatArrayTransfer2 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer2.valuesFlat,
+						    bitRatio = _formatArrayTransfer2.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', dim);
+							this.setUniform2iv('user_' + name + 'Size', size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				case 'Number':
+					{
+						this.setUniform1f('user_' + name, 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.constantsLength + 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 _formatArrayTransfer3 = this._formatArrayTransfer(value.value, _length),
+						    _valuesFlat = _formatArrayTransfer3.valuesFlat,
+						    _bitRatio = _formatArrayTransfer3.bitRatio;
+
+						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(_valuesFlat.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0] / _bitRatio, _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', _dim);
+							this.setUniform2iv('user_' + name + 'Size', _size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', _bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim2 = [inputImage.width, inputImage.height, 1];
+						var _size2 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var mipLevel = 0; 
+						var internalFormat = gl.RGBA; 
+						var srcFormat = gl.RGBA; 
+						var srcType = gl.UNSIGNED_BYTE; 
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('user_' + name + 'Dim', _dim2);
+						this.setUniform2iv('user_' + name + 'Size', _size2);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim3 = inputTexture.dimensions;
+						var _size3 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('user_' + name + 'Dim', _dim3);
+						this.setUniform2iv('user_' + name + 'Size', _size3);
+						this.setUniform1i('user_' + name + 'BitRatio', 1); 
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+			this.argumentsLength++;
+		}
+
+
+	}, {
+		key: '_addConstant',
+		value: function _addConstant(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength);
+						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 _formatArrayTransfer4 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer4.valuesFlat,
+						    bitRatio = _formatArrayTransfer4.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', dim);
+							this.setUniform2iv('constants_' + name + 'Size', size);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Input':
+					{
+						var input = value;
+						var _dim4 = input.size;
+						var _size4 = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, _dim4);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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 _length2 = _size4[0] * _size4[1];
+
+						var _formatArrayTransfer5 = this._formatArrayTransfer(value.value, _length2),
+						    _valuesFlat2 = _formatArrayTransfer5.valuesFlat,
+						    _bitRatio2 = _formatArrayTransfer5.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size4[0], _size4[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer2 = new Uint8Array(_valuesFlat2.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size4[0] / _bitRatio2, _size4[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer2);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', _dim4);
+							this.setUniform2iv('constants_' + name + 'Size', _size4);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', _bitRatio2);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim5 = [inputImage.width, inputImage.height, 1];
+						var _size5 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						var mipLevel = 0; 
+						var internalFormat = gl.RGBA; 
+						var srcFormat = gl.RGBA; 
+						var srcType = gl.UNSIGNED_BYTE; 
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('constants_' + name + 'Dim', _dim5);
+						this.setUniform2iv('constants_' + name + 'Size', _size5);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim6 = inputTexture.dimensions;
+						var _size6 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('constants_' + name + 'Dim', _dim6);
+						this.setUniform2iv('constants_' + name + 'Size', _size6);
+						this.setUniform1i('constants_' + name + 'BitRatio', 1); 
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+		}
+
+
+	}, {
+		key: '_formatArrayTransfer',
+		value: function _formatArrayTransfer(value, length) {
+			var bitRatio = 1; 
+			var valuesFlat = value;
+			if (utils.isArray(value[0]) || this.floatTextures) {
+				valuesFlat = new Float32Array(length);
+				utils.flattenTo(value, valuesFlat);
+			} else {
+
+				switch (value.constructor) {
+					case Uint8Array:
+					case Int8Array:
+						bitRatio = 4;
+						break;
+					case Uint16Array:
+					case Int16Array:
+						bitRatio = 2;
+					case Float32Array:
+					case Int32Array:
+						break;
+
+					default:
+						valuesFlat = new Float32Array(length);
+						utils.flattenTo(value, valuesFlat);
+				}
+			}
+			return {
+				bitRatio: bitRatio,
+				valuesFlat: valuesFlat
+			};
+		}
+
+
+	}, {
+		key: '_getHeaderString',
+		value: function _getHeaderString() {
+			return this.subKernels !== null || this.subKernelProperties !== null ?
+			'#extension GL_EXT_draw_buffers : require\n' : '';
+		}
+
+
+	}, {
+		key: '_getLoopMaxString',
+		value: function _getLoopMaxString() {
+			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + '.0;\n' : ' 1000.0;\n';
+		}
+
+
+	}, {
+		key: '_getConstantsString',
+		value: function _getConstantsString() {
+			var result = [];
+			var threadDim = this.threadDim;
+			var texSize = this.texSize;
+			if (this.hardcodeConstants) {
+				result.push('ivec3 uOutputDim = ivec3(' + threadDim[0] + ',' + threadDim[1] + ', ' + threadDim[2] + ')', 'ivec2 uTexSize = ivec2(' + texSize[0] + ', ' + texSize[1] + ')');
+			} else {
+				result.push('uniform ivec3 uOutputDim', 'uniform ivec2 uTexSize');
+			}
+
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_getTextureCoordinate',
+		value: function _getTextureCoordinate() {
+			var names = this.subKernelOutputVariableNames;
+			if (names === null || names.length < 1) {
+				return 'varying vec2 vTexCoord;\n';
+			} else {
+				return 'out vec2 vTexCoord;\n';
+			}
+		}
+
+
+	}, {
+		key: '_getDecode32EndiannessString',
+		value: function _getDecode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
+
+
+	}, {
+		key: '_getEncode32EndiannessString',
+		value: function _getEncode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
+
+
+	}, {
+		key: '_getDivideWithIntegerCheckString',
+		value: function _getDivideWithIntegerCheckString() {
+			return this.fixIntegerDivisionAccuracy ? '\n\t\t\t  float div_with_int_check(float x, float y) {\n\t\t\t  if (floor(x) == x && floor(y) == y && integerMod(x, y) == 0.0) {\n\t\t\t    return float(int(x)/int(y));\n\t\t\t  }\n\t\t\t  return x / y;\n\t\t\t}\n\t\t\t' : '';
+		}
+
+
+	}, {
+		key: '_getGetWraparoundString',
+		value: function _getGetWraparoundString() {
+			return this.wraparound ? '  xyz = mod(xyz, texDim);\n' : '';
+		}
+
+
+	}, {
+		key: '_getGetTextureChannelString',
+		value: function _getGetTextureChannelString() {
+			if (!this.floatTextures) return '';
+
+			return this._linesToString(['  int channel = integerMod(index, 4)', '  index = index / 4']);
+		}
+
+
+	}, {
+		key: '_getGetTextureIndexString',
+		value: function _getGetTextureIndexString() {
+			return this.floatTextures ? '  index = index / 4;\n' : '';
+		}
+
+
+	}, {
+		key: '_getGetResultString',
+		value: function _getGetResultString() {
+			if (!this.floatTextures) {
+				return '  return decode(texel, x, bitRatio);';
+			}
+			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: '_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 === 'NumberTexture' || paramType === 'ArrayTexture(4)') {
+						var paramDim = utils.getDimensions(param, true);
+						var paramSize = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, paramDim);
+
+						result.push('uniform sampler2D user_' + paramName, 'ivec2 user_' + paramName + 'Size = ivec2(' + paramSize[0] + ', ' + paramSize[1] + ')', 'ivec3 user_' + paramName + 'Dim = ivec3(' + paramDim[0] + ', ' + paramDim[1] + ', ' + paramDim[2] + ')', 'uniform int user_' + paramName + 'BitRatio');
+					} else if (paramType === 'Integer') {
+						result.push('float user_' + paramName + ' = ' + param + '.0');
+					} else if (paramType === 'Float') {
+						result.push('float user_' + paramName + ' = ' + param);
+					}
+				} else {
+					if (paramType === 'Array' || paramType === 'NumberTexture' || paramType === 'ArrayTexture(4)' || paramType === 'Input' || paramType === 'HTMLImage') {
+						result.push('uniform sampler2D user_' + paramName, 'uniform ivec2 user_' + paramName + 'Size', 'uniform ivec3 user_' + paramName + 'Dim');
+						if (paramType !== 'HTMLImage') {
+							result.push('uniform int user_' + paramName + 'BitRatio');
+						}
+					} else if (paramType === 'Integer' || paramType === 'Float') {
+						result.push('uniform float user_' + paramName);
+					} else {
+						throw new Error('Param type ' + paramType + ' not supported in WebGL, only WebGL2');
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_getMainConstantsString',
+		value: function _getMainConstantsString() {
+			var result = [];
+			if (this.constants) {
+				for (var name in this.constants) {
+					if (!this.constants.hasOwnProperty(name)) continue;
+					var value = this.constants[name];
+					var type = utils.getArgumentType(value);
+					switch (type) {
+						case 'Integer':
+							result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
+							break;
+						case 'Float':
+							result.push('const float constants_' + name + ' = ' + parseFloat(value));
+							break;
+						case 'Array':
+						case 'Input':
+						case 'HTMLImage':
+						case 'NumberTexture':
+						case 'ArrayTexture(4)':
+							result.push('uniform sampler2D constants_' + name, 'uniform ivec2 constants_' + name + 'Size', 'uniform ivec3 constants_' + name + 'Dim', 'uniform int constants_' + name + 'BitRatio');
+							break;
+						default:
+							throw new Error('Unsupported constant ' + name + ' type ' + type);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_getKernelString',
+		value: function _getKernelString() {
+			var result = [];
+			var names = this.subKernelOutputVariableNames;
+			if (names !== null) {
+				result.push('float kernelResult = 0.0');
+				for (var i = 0; i < names.length; i++) {
+					result.push('float ' + names[i] + ' = 0.0');
+				}
+			} else {
+				result.push('float kernelResult = 0.0');
+			}
+
+			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+		}
+
+
+	}, {
+		key: '_getMainResultString',
+		value: function _getMainResultString() {
+			var names = this.subKernelOutputVariableNames;
+			var result = [];
+
+			if (this.floatOutput) {
+				result.push('  index *= 4');
+			}
+
+			if (this.graphical) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = actualColor');
+			} else if (this.floatOutput) {
+				var channels = ['r', 'g', 'b', 'a'];
+
+				for (var i = 0; i < channels.length; ++i) {
+					result.push('  threadId = indexTo3D(index, uOutputDim)');
+					result.push('  kernel()');
+
+					if (names) {
+						result.push('  gl_FragData[0].' + channels[i] + ' = kernelResult');
+
+						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');
+					}
+
+					if (i < channels.length - 1) {
+						result.push('  index += 1');
+					}
+				}
+			} else if (names !== null) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)');
+				result.push('  kernel()');
+				result.push('  gl_FragData[0] = encode32(kernelResult)');
+				for (var _i2 = 0; _i2 < names.length; _i2++) {
+					result.push('  gl_FragData[' + (_i2 + 1) + '] = encode32(' + names[_i2] + ')');
+				}
+			} else {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = encode32(kernelResult)');
+			}
+
+			return this._linesToString(result);
+		}
+
+
+	}, {
+		key: '_linesToString',
+		value: function _linesToString(lines) {
+			if (lines.length > 0) {
+				return lines.join(';\n') + ';\n';
+			} else {
+				return '\n';
+			}
+		}
+
+
+	}, {
+		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: '_addKernels',
+		value: function _addKernels() {
+			var _this2 = this;
+
+			var builder = this.functionBuilder;
+			var gl = this._webGl;
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+			builder.addNativeFunctions(this.nativeFunctions);
+
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				paramNames: this.paramNames,
+				paramTypes: this.paramTypes,
+				constantTypes: this.constantTypes,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+
+			if (this.subKernels !== null) {
+				var drawBuffers = this.drawBuffers = gl.getExtension('WEBGL_draw_buffers');
+				if (!drawBuffers) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputVariableNames = [];
+				this.subKernels.forEach(function (subKernel) {
+					return _this2._addSubKernel(subKernel);
+				});
+			} else if (this.subKernelProperties !== null) {
+				var _drawBuffers = this.drawBuffers = gl.getExtension('WEBGL_draw_buffers');
+				if (!_drawBuffers) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputVariableNames = [];
+				Object.keys(this.subKernelProperties).forEach(function (property) {
+					return _this2._addSubKernel(_this2.subKernelProperties[property]);
+				});
+			}
+		}
+	}, {
+		key: '_addSubKernel',
+		value: function _addSubKernel(subKernel) {
+			this.functionBuilder.addSubKernel(subKernel, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+			this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
+		}
+
+
+	}, {
+		key: '_getFragShaderString',
+		value: function _getFragShaderString(args) {
+			if (this.compiledFragShaderString !== null) {
+				return this.compiledFragShaderString;
+			}
+			return this.compiledFragShaderString = this._replaceArtifacts(this.constructor.fragShaderString, this._getFragShaderArtifactMap(args));
+		}
+
+
+	}, {
+		key: '_getVertShaderString',
+		value: function _getVertShaderString(args) {
+			if (this.compiledVertShaderString !== null) {
+				return this.compiledVertShaderString;
+			}
+			return this.compiledVertShaderString = this.constructor.vertShaderString;
+		}
+
+
+	}, {
+		key: 'toString',
+		value: function toString() {
+			return kernelString(this);
+		}
+	}, {
+		key: 'addFunction',
+		value: function addFunction(fn) {
+			this.functionBuilder.addFunction(null, fn);
+		}
+	}, {
+		key: 'destroy',
+		value: function destroy(removeCanvasReferences) {
+			_get(WebGLKernel.prototype.__proto__ || Object.getPrototypeOf(WebGLKernel.prototype), 'destroy', this).call(this);
+			if (this.outputTexture) {
+				this._webGl.deleteTexture(this.outputTexture);
+			}
+			if (this.buffer) {
+				this._webGl.deleteBuffer(this.buffer);
+			}
+			if (this.framebuffer) {
+				this._webGl.deleteFramebuffer(this.framebuffer);
+			}
+
+			if (this.vertShader) {
+				this._webGl.deleteShader(this.vertShader);
+			}
+
+			if (this.fragShader) {
+				this._webGl.deleteShader(this.fragShader);
+			}
+
+			if (this.program) {
+				this._webGl.deleteProgram(this.program);
+			}
+
+			var keys = Object.keys(this.textureCache);
+
+			for (var i = 0; i < keys.length; i++) {
+				var name = keys[i];
+				this._webGl.deleteTexture(this.textureCache[name]);
+			}
+
+			if (this.subKernelOutputTextures) {
+				for (var _i3 = 0; _i3 < this.subKernelOutputTextures.length; _i3++) {
+					this._webGl.deleteTexture(this.subKernelOutputTextures[_i3]);
+				}
+			}
+			if (removeCanvasReferences) {
+				var idx = canvases.indexOf(this._canvas);
+				if (idx >= 0) {
+					canvases[idx] = null;
+					maxTexSizes[idx] = null;
+				}
+			}
+			delete this._webGl;
+		}
+	}]);
+
+	return WebGLKernel;
+}(KernelBase);
+},{"../../core/texture":30,"../../core/utils":32,"../kernel-base":8,"./kernel-string":20,"./shader-frag":23,"./shader-vert":24}],22:[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"); } }
+
+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 RunnerBase = require('../runner-base');
+var WebGLKernel = require('./kernel');
+var WebGLFunctionBuilder = require('./function-builder');
+
+module.exports = function (_RunnerBase) {
+	_inherits(WebGLRunner, _RunnerBase);
+
+	function WebGLRunner(settings) {
+		_classCallCheck(this, WebGLRunner);
+
+		var _this = _possibleConstructorReturn(this, (WebGLRunner.__proto__ || Object.getPrototypeOf(WebGLRunner)).call(this, new WebGLFunctionBuilder(), settings));
+
+		_this.Kernel = WebGLKernel;
+		_this.kernel = null;
+		return _this;
+	}
+
+
+
+	_createClass(WebGLRunner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'gpu';
+		}
+	}]);
+
+	return WebGLRunner;
+}(RunnerBase);
+},{"../runner-base":10,"./function-builder":18,"./kernel":21}],23:[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\n__CONSTANTS__;\n\nvarying vec2 vTexCoord;\n\nvec4 round(vec4 x) {\n  return floor(x + 0.5);\n}\n\nfloat round(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\nfloat integerMod(float x, float y) {\n  float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nint integerMod(int x, int y) {\n  return x - (y * int(x / y));\n}\n\n__DIVIDE_WITH_INTEGER_CHECK__;\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\nfloat decode32(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\nvec4 encode32(float f) {\n  float F = abs(f);\n  float sign = f < 0.0 ? 1.0 : 0.0;\n  float exponent = floor(log2(F));\n  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\nfloat decode(vec4 rgba, int x, int bitRatio) {\n  if (bitRatio == 1) {\n    return decode32(rgba);\n  }\n  __DECODE32_ENDIANNESS__;\n  int channel = integerMod(x, bitRatio);\n  if (bitRatio == 4) {\n    if (channel == 0) return rgba.r * 255.0;\n    if (channel == 1) return rgba.g * 255.0;\n    if (channel == 2) return rgba.b * 255.0;\n    if (channel == 3) return rgba.a * 255.0;\n  }\n  else {\n    if (channel == 0) return rgba.r * 255.0 + rgba.g * 65280.0;\n    if (channel == 1) return rgba.b * 255.0 + rgba.a * 65280.0;\n  }\n}\n\nint index;\nivec3 threadId;\n\nivec3 indexTo3D(int idx, ivec3 texDim) {\n  int z = int(idx / (texDim.x * texDim.y));\n  idx -= z * int(texDim.x * texDim.y);\n  int y = int(idx / texDim.x);\n  int x = int(integerMod(idx, texDim.x));\n  return ivec3(x, y, z);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio,  int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  vec4 texel = texture2D(tex, st / vec2(texSize));\n  __GET_RESULT__;\n  \n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture2D(tex, st / vec2(texSize));\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int y, int x) {\n  return get(tex, texSize, texDim, bitRatio, int(0), y, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int y, int x) {\n  return getImage2D(tex, texSize, texDim, int(0), y, x);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int x) {\n  return get(tex, texSize, texDim, bitRatio, int(0), int(0), x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int x) {\n  return getImage2D(tex, texSize, texDim, int(0), int(0), x);\n}\n\n\nvec4 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\nvoid color(sampler2D image) {\n  actualColor = texture2D(image, vTexCoord);\n}\n\n__MAIN_PARAMS__;\n__MAIN_CONSTANTS__;\n__KERNEL__;\n\nvoid main(void) {\n  index = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
+},{}],24:[function(require,module,exports){
+"use strict";
+
+module.exports = "precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nattribute vec2 aPos;\nattribute vec2 aTexCoord;\n\nvarying 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}";
+},{}],25:[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"); } }
+
+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 WebGLKernel = require('./kernel');
+var utils = require('../../core/utils');
+
+module.exports = function (_WebGLKernel) {
+	_inherits(WebGLValidatorKernel, _WebGLKernel);
+
+	function WebGLValidatorKernel() {
+		_classCallCheck(this, WebGLValidatorKernel);
+
+		return _possibleConstructorReturn(this, (WebGLValidatorKernel.__proto__ || Object.getPrototypeOf(WebGLValidatorKernel)).apply(this, arguments));
+	}
+
+	_createClass(WebGLValidatorKernel, [{
+		key: 'validateOptions',
+
+
+		value: function validateOptions() {
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+		}
+	}]);
+
+	return WebGLValidatorKernel;
+}(WebGLKernel);
+},{"../../core/utils":32,"./kernel":21}],26:[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":32}],27:[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");
+
+module.exports = function () {
+	function GPUCore() {
+		_classCallCheck(this, GPUCore);
+	}
+
+	_createClass(GPUCore, null, [{
+		key: "validateKernelObj",
+
+
+		value: function validateKernelObj(kernelObj) {
+
+			if (kernelObj === null) {
+				throw "KernelObj being validated is NULL";
+			}
+
+			if (typeof kernelObj === "string") {
+				try {
+					kernelObj = JSON.parse(kernelObj);
+				} catch (e) {
+					console.error(e);
+					throw "Failed to convert KernelObj from JSON string";
+				}
+
+				if (kernelObj === null) {
+					throw "Invalid (NULL) KernelObj JSON string representation";
+				}
+			}
+
+			if (kernelObj.isKernelObj !== true) {
+				throw "Failed missing isKernelObj flag check";
+			}
+
+			return kernelObj;
+		}
+
+
+	}, {
+		key: "loadKernelObj",
+		value: function loadKernelObj(kernelObj, inOpt) {
+
+			kernelObj = validateKernelObj(kernelObj);
+		}
+	}]);
+
+	return GPUCore;
+}();
+},{"./utils-core":31}],28:[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"); } }
+
+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 utils = require('./utils');
+var WebGLRunner = require('../backend/web-gl/runner');
+var WebGL2Runner = require('../backend/web-gl2/runner');
+var CPURunner = require('../backend/cpu/runner');
+var WebGLValidatorKernel = require('../backend/web-gl/validator-kernel');
+var WebGL2ValidatorKernel = require('../backend/web-gl2/validator-kernel');
+var GPUCore = require("./gpu-core");
+
+
+var GPU = function (_GPUCore) {
+	_inherits(GPU, _GPUCore);
+
+	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 {
+			if (_this._webGl) {
+				if (typeof WebGL2RenderingContext !== 'undefined' && _this._webGl.constructor === WebGL2RenderingContext) {
+					detectedMode = 'webgl2';
+				} else if (typeof WebGLRenderingContext !== 'undefined' && _this._webGl.constructor === WebGLRenderingContext) {
+					detectedMode = 'webgl';
+				} else {
+					throw new Error('unknown WebGL Context');
+				}
+			} 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 'gpu':
+				var Runner = _this.getGPURunner();
+				_this._runner = new Runner(runnerSettings);
+				break;
+
+			case 'webgl2':
+				_this._runner = new WebGL2Runner(runnerSettings);
+				break;
+			case 'webgl':
+				_this._runner = new WebGLRunner(runnerSettings);
+				break;
+
+			case 'webgl2-validator':
+				_this._runner = new WebGL2Runner(runnerSettings);
+				_this._runner.Kernel = WebGL2ValidatorKernel;
+				break;
+			case 'webgl-validator':
+				_this._runner = new WebGLRunner(runnerSettings);
+				_this._runner.Kernel = WebGLValidatorKernel;
+				break;
+			default:
+				throw new Error('"' + mode + '" mode is not defined');
+		}
+		return _this;
+	}
+
+
+	_createClass(GPU, [{
+		key: 'createKernel',
+		value: function createKernel(fn, settings) {
+			if (typeof fn === 'undefined') {
+				throw 'Missing fn parameter';
+			}
+			if (!utils.isFunction(fn) && typeof fn !== 'string') {
+				throw 'fn parameter not a function';
+			}
+
+			var mergedSettings = Object.assign({
+				webGl: this._webGl,
+				canvas: this._canvas
+			}, settings || {});
+
+			var kernel = this._runner.buildKernel(fn, mergedSettings);
+
+			if (!this._canvas) {
+				this._canvas = kernel.getCanvas();
+			}
+			if (!this._runner.canvas) {
+				this._runner.canvas = kernel.getCanvas();
+			}
+
+			this.kernels.push(kernel);
+
+			return kernel;
+		}
+
+
+	}, {
+		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]);
+				}
+			}
+
+			return kernel;
+		}
+
+
+	}, {
+		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();
+
+			for (var i = 0; i < arguments.length - 1; i++) {
+				arguments[i].setCanvas(canvas).setWebGl(webGl).setOutputToTexture(true);
+			}
+
+			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) {
+					var w = texSize[0];
+					var h = Math.ceil(texSize[1] / 4);
+					result = new Float32Array(w * h * 4);
+					gl.readPixels(0, 0, w, h, 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);
+				}
+
+				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]);
+					});
+				}
+			};
+		}
+	}, {
+		key: 'getGPURunner',
+		value: function getGPURunner() {
+			if (typeof WebGL2RenderingContext !== 'undefined' && utils.isWebGl2Supported()) return WebGL2Runner;
+			if (typeof WebGLRenderingContext !== 'undefined') return WebGLRunner;
+		}
+
+
+	}, {
+		key: 'addFunction',
+		value: function addFunction(fn, options) {
+			this._runner.functionBuilder.addFunction(null, fn, options);
+			return this;
+		}
+
+
+	}, {
+		key: 'addNativeFunction',
+		value: function addNativeFunction(name, nativeFunction) {
+			this._runner.functionBuilder.addNativeFunction(name, nativeFunction);
+			return this;
+		}
+
+
+	}, {
+		key: 'getMode',
+		value: function getMode() {
+			return this._runner.getMode();
+		}
+
+
+	}, {
+		key: 'isWebGlSupported',
+		value: function isWebGlSupported() {
+			return utils.isWebGlSupported();
+		}
+
+
+	}, {
+		key: 'hasIntegerDivisionAccuracyBug',
+		value: function hasIntegerDivisionAccuracyBug() {
+			return utils.hasIntegerDivisionAccuracyBug();
+		}
+
+
+	}, {
+		key: 'getCanvas',
+		value: function getCanvas() {
+			return this._canvas;
+		}
+
+
+	}, {
+		key: 'getWebGl',
+		value: function getWebGl() {
+			return this._webGl;
+		}
+
+
+	}, {
+		key: 'destroy',
+		value: function destroy() {
+			var _this2 = this;
+
+			setTimeout(function () {
+				var kernels = _this2.kernels;
+
+				var destroyWebGl = !_this2._webGl && kernels.length && kernels[0]._webGl;
+				for (var i = 0; i < _this2.kernels.length; i++) {
+					_this2.kernels[i].destroy(true); 
+				}
+
+				if (destroyWebGl) {
+					destroyWebGl.OES_texture_float = null;
+					destroyWebGl.OES_texture_float_linear = null;
+					destroyWebGl.OES_element_index_uint = null;
+					var loseContextExt = destroyWebGl.getExtension('WEBGL_lose_context');
+					if (loseContextExt) {
+						loseContextExt.loseContext();
+					}
+				}
+			}, 0);
+		}
+	}]);
+
+	return GPU;
+}(GPUCore);
+
+;
+
+Object.assign(GPU, GPUCore);
+
+module.exports = GPU;
+},{"../backend/cpu/runner":5,"../backend/web-gl/runner":22,"../backend/web-gl/validator-kernel":25,"../backend/web-gl2/runner":14,"../backend/web-gl2/validator-kernel":17,"./gpu-core":27,"./utils":32}],29:[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];
+		}
+	}
+};
+},{}],30:[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"); } }
+
+module.exports = function () {
+
+	function Texture(texture, size, dimensions, output, webGl) {
+		var type = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 'NumberTexture';
+
+		_classCallCheck(this, Texture);
+
+		this.texture = texture;
+		this.size = size;
+		this.dimensions = dimensions;
+		this.output = output;
+		this.webGl = webGl;
+		this.kernel = null;
+		this.type = type;
+	}
+
+
+
+	_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);
+
+			this.kernel = gpu.createKernel(function (x) {
+				return x[this.thread.z][this.thread.y][this.thread.x];
+			}).setOutput(this.output);
+
+			return this.kernel(this);
+		}
+
+
+	}, {
+		key: 'delete',
+		value: function _delete() {
+			return this.webGl.deleteTexture(this.texture);
+		}
+	}]);
+
+	return Texture;
+}();
+},{}],31:[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 = function () {
+	function UtilsCore() {
+		_classCallCheck(this, UtilsCore);
+	}
+
+	_createClass(UtilsCore, null, [{
+		key: 'isCanvas',
+
+
+
+
+
+		value: function isCanvas(canvasObj) {
+			return canvasObj !== null && (canvasObj.nodeName && canvasObj.getContext && canvasObj.nodeName.toUpperCase() === 'CANVAS' || typeof OffscreenCanvas !== 'undefined' && canvasObj instanceof OffscreenCanvas);
+		}
+
+
+	}, {
+		key: 'isCanvasSupported',
+		value: function isCanvasSupported() {
+			return _isCanvasSupported;
+		}
+
+
+	}, {
+		key: 'initCanvas',
+		value: function initCanvas() {
+			if (!_isCanvasSupported) {
+				return null;
+			}
+
+			var canvas = typeof document !== 'undefined' ? document.createElement('canvas') : new OffscreenCanvas(0, 0);
+
+			canvas.width = 2;
+			canvas.height = 2;
+
+			return canvas;
+		}
+
+
+
+
+	}, {
+		key: 'isWebGl',
+		value: function isWebGl(webGlObj) {
+			return webGlObj && typeof webGlObj.getExtension === 'function';
+		}
+
+
+	}, {
+		key: 'isWebGl2',
+		value: function isWebGl2(webGl2Obj) {
+			return webGl2Obj && typeof WebGL2RenderingContext !== 'undefined' && webGl2Obj instanceof WebGL2RenderingContext;
+		}
+
+
+	}, {
+		key: 'isWebGlSupported',
+		value: function isWebGlSupported() {
+			return _isWebGlSupported;
+		}
+
+
+	}, {
+		key: 'isWebGl2Supported',
+		value: function isWebGl2Supported() {
+			return _isWebGl2Supported;
+		}
+	}, {
+		key: 'isWebGlDrawBuffersSupported',
+		value: function isWebGlDrawBuffersSupported() {
+			return _isWebGlDrawBuffersSupported;
+		}
+
+
+	}, {
+		key: 'initWebGlDefaultOptions',
+		value: function initWebGlDefaultOptions() {
+			return {
+				alpha: false,
+				depth: false,
+				antialias: false
+			};
+		}
+
+
+	}, {
+		key: 'initWebGl',
+		value: function initWebGl(canvasObj) {
+
+			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
+				if (!_isCanvasSupported) {
+					return null;
+				}
+			}
+
+			if (!UtilsCore.isCanvas(canvasObj)) {
+				throw new Error('Invalid canvas object - ' + canvasObj);
+			}
+
+			var webGl = null;
+			var defaultOptions = UtilsCore.initWebGlDefaultOptions();
+			try {
+				webGl = canvasObj.getContext('experimental-webgl', defaultOptions);
+			} catch (e) {
+			}
+
+			if (webGl === null) {
+				webGl = canvasObj.getContext('webgl2', defaultOptions) || canvasObj.getContext('webgl', defaultOptions);
+			}
+
+			if (webGl) {
+				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 webGl;
+		}
+
+
+	}, {
+		key: 'initWebGl2',
+		value: function initWebGl2(canvasObj) {
+
+			if (typeof _isCanvasSupported !== 'undefined' || canvasObj === null) {
+				if (!_isCanvasSupported) {
+					return null;
+				}
+			}
+
+			if (!UtilsCore.isCanvas(canvasObj)) {
+				throw new Error('Invalid canvas object - ' + canvasObj);
+			}
+
+			return canvasObj.getContext('webgl2', UtilsCore.initWebGlDefaultOptions());
+		}
+
+
+	}, {
+		key: 'checkOutput',
+		value: function checkOutput(output) {
+			if (!output || !Array.isArray(output)) throw new Error('kernel.output not an array');
+			for (var i = 0; i < output.length; i++) {
+				if (isNaN(output[i]) || output[i] < 1) {
+					throw new Error('kernel.output[' + i + '] incorrectly defined as `' + output[i] + '`, needs to be numeric, and greater than 0');
+				}
+			}
+		}
+	}]);
+
+	return UtilsCore;
+}();
+
+
+var _isCanvasSupported = typeof document !== 'undefined' ? UtilsCore.isCanvas(document.createElement('canvas')) : typeof OffscreenCanvas !== 'undefined';
+var _testingWebGl = UtilsCore.initWebGl(UtilsCore.initCanvas());
+var _testingWebGl2 = UtilsCore.initWebGl2(UtilsCore.initCanvas());
+var _isWebGlSupported = UtilsCore.isWebGl(_testingWebGl);
+var _isWebGl2Supported = UtilsCore.isWebGl2(_testingWebGl2);
+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;
+},{}],32:[function(require,module,exports){
+'use strict';
+
+
+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');
+var FUNCTION_NAME = /function ([^(]*)/;
+
+var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+
+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 _isFloatReadPixelsSupportedWebGL2 = null;
+
+var _isMixedIdentifiersSupported = function () {
+	try {
+		new Function('let i = 1; const j = 1;')();
+		return true;
+	} catch (e) {
+		return false;
+	}
+}();
+
+var _hasIntegerDivisionAccuracyBug = null;
+
+
+var Utils = function (_UtilsCore) {
+	_inherits(Utils, _UtilsCore);
+
+	function Utils() {
+		_classCallCheck(this, Utils);
+
+		return _possibleConstructorReturn(this, (Utils.__proto__ || Object.getPrototypeOf(Utils)).apply(this, arguments));
+	}
+
+	_createClass(Utils, null, [{
+		key: 'systemEndianness',
+
+
+
+		value: function systemEndianness() {
+			return _systemEndianness;
+		}
+
+
+
+	}, {
+		key: 'isFunction',
+		value: function isFunction(funcObj) {
+			return typeof funcObj === 'function';
+		}
+
+
+	}, {
+		key: 'isFunctionString',
+		value: function isFunctionString(funcStr) {
+			if (funcStr !== null) {
+				return funcStr.toString().slice(0, 'function'.length).toLowerCase() === 'function';
+			}
+			return false;
+		}
+
+
+	}, {
+		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('}'));
+		}
+
+
+	}, {
+		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;
+		}
+
+
+
+	}, {
+		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(); 
+
+			for (var key in obj) {
+				if (Object.prototype.hasOwnProperty.call(obj, key)) {
+					obj.isActiveClone = null;
+					temp[key] = Utils.clone(obj[key]);
+					delete obj.isActiveClone;
+				}
+			}
+
+			return temp;
+		}
+
+
+	}, {
+		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);
+		}
+
+
+	}, {
+		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: 'isArray',
+		value: function isArray(array) {
+			if (isNaN(array.length)) {
+				return false;
+			}
+
+			return true;
+		}
+
+
+	}, {
+		key: 'getArgumentType',
+		value: function getArgumentType(arg) {
+			if (Utils.isArray(arg)) {
+				if (arg[0].nodeName === 'IMG') {
+					return 'HTMLImageArray';
+				}
+				return 'Array';
+			} else if (typeof arg === 'number') {
+				if (Number.isInteger(arg)) {
+					return 'Integer';
+				}
+				return 'Float';
+			} else if (arg instanceof Texture) {
+				return arg.type;
+			} else if (arg instanceof Input) {
+				return 'Input';
+			} else if (arg.nodeName === 'IMG') {
+				return 'HTMLImage';
+			} else {
+				return 'Unknown';
+			}
+		}
+
+
+	}, {
+		key: 'isFloatReadPixelsSupported',
+		value: function isFloatReadPixelsSupported() {
+			if (_isFloatReadPixelsSupported !== null) {
+				return _isFloatReadPixelsSupported;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl-validator'
+			});
+			var x = gpu.createKernel(function () {
+				return 1;
+			}, {
+				output: [2],
+				floatTextures: true,
+				floatOutput: true,
+				floatOutputForce: true
+			})();
+
+			_isFloatReadPixelsSupported = x[0] === 1;
+			gpu.destroy();
+			return _isFloatReadPixelsSupported;
+		}
+
+
+	}, {
+		key: 'isFloatReadPixelsSupportedWebGL2',
+		value: function isFloatReadPixelsSupportedWebGL2() {
+			if (_isFloatReadPixelsSupportedWebGL2 !== null) {
+				return _isFloatReadPixelsSupportedWebGL2;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl2-validator'
+			});
+			var x = gpu.createKernel(function () {
+				return 1;
+			}, {
+				output: [2],
+				floatTextures: true,
+				floatOutput: true,
+				floatOutputForce: true
+			})();
+
+			_isFloatReadPixelsSupportedWebGL2 = x[0] === 1;
+			gpu.destroy();
+			return _isFloatReadPixelsSupportedWebGL2;
+		}
+
+
+	}, {
+		key: 'hasIntegerDivisionAccuracyBug',
+		value: function hasIntegerDivisionAccuracyBug() {
+			if (_hasIntegerDivisionAccuracyBug !== null) {
+				return _hasIntegerDivisionAccuracyBug;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl-validator'
+			});
+			var x = gpu.createKernel(function (v1, v2) {
+				return v1[this.thread.x] / v2[this.thread.x];
+			}, {
+				output: [1]
+			})([6, 6030401], [3, 3991]);
+
+			_hasIntegerDivisionAccuracyBug = x[0] !== 2 || x[1] !== 1511;
+			gpu.destroy();
+			return _hasIntegerDivisionAccuracyBug;
+		}
+	}, {
+		key: 'isMixedIdentifiersSupported',
+		value: function isMixedIdentifiersSupported() {
+			return _isMixedIdentifiersSupported;
+		}
+	}, {
+		key: 'dimToTexSize',
+		value: function dimToTexSize(opt, dimensions, output) {
+			var numTexels = dimensions[0];
+			var w = dimensions[0];
+			var h = dimensions[1];
+			for (var i = 1; i < dimensions.length; i++) {
+				numTexels *= dimensions[i];
+			}
+
+			if (opt.floatTextures && (!output || opt.floatOutput)) {
+				w = numTexels = Math.ceil(numTexels / 4);
+			}
+			if (h > 1 && w * h === numTexels) {
+				return [w, h];
+			}
+			var sqrt = Math.sqrt(numTexels);
+			var high = Math.ceil(sqrt);
+			var low = Math.floor(sqrt);
+			while (high * low > numTexels) {
+				high--;
+				low = Math.ceil(numTexels / high);
+			}
+			w = low;
+			h = Math.ceil(numTexels / w);
+			return [w, h];
+		}
+
+
+	}, {
+		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 new Int32Array(ret);
+		}
+
+
+	}, {
+		key: 'pad',
+		value: function pad(arr, padding) {
+			function zeros(n) {
+				return Array.apply(null, new Array(n)).map(Number.prototype.valueOf, 0);
+			}
+
+			var len = arr.length + padding * 2;
+
+			var ret = arr.map(function (x) {
+				return [].concat(zeros(padding), x, zeros(padding));
+			});
+
+			for (var i = 0; i < padding; i++) {
+				ret = [].concat([zeros(len)], ret, [zeros(len)]);
+			}
+
+			return ret;
+		}
+
+
+	}, {
+		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: '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: '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: 'splitArray',
+		value: function splitArray(array, part) {
+			var result = [];
+			for (var i = 0; i < array.length; i += part) {
+				result.push(new array.constructor(array.buffer, i * 4 + array.byteOffset, 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 = [];
+
+			do {
+				props.push.apply(props, Object.getOwnPropertyNames(obj));
+			} while (obj = Object.getPrototypeOf(obj));
+
+			return props;
+		}
+	}]);
+
+	return Utils;
+}(UtilsCore);
+
+
+
+Object.assign(Utils, UtilsCore);
+
+module.exports = Utils;
+},{"../index":33,"./input":29,"./texture":30,"./utils-core":31}],33:[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');
+
+var WebGL2FunctionBuilder = require('./backend/web-gl2/function-builder');
+var WebGL2FunctionNode = require('./backend/web-gl2/function-node');
+var WebGL2Kernel = require('./backend/web-gl2/kernel');
+var WebGL2Runner = require('./backend/web-gl2/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;
+
+GPU.WebGL2FunctionBuilder = WebGL2FunctionBuilder;
+GPU.WebGL2FunctionNode = WebGL2FunctionNode;
+GPU.WebGL2Kernel = WebGL2Kernel;
+GPU.WebGL2Runner = WebGL2Runner;
+
+if (typeof module !== 'undefined') {
+	module.exports = GPU;
+}
+if (typeof window !== 'undefined') {
+	window.GPU = GPU;
+}
+if (typeof self !== 'undefined') {
+	self.GPU = GPU;
+}
+},{"./backend/cpu/function-builder":1,"./backend/cpu/function-node":2,"./backend/cpu/kernel":4,"./backend/cpu/runner":5,"./backend/web-gl/function-builder":18,"./backend/web-gl/function-node":19,"./backend/web-gl/kernel":21,"./backend/web-gl/runner":22,"./backend/web-gl2/function-builder":11,"./backend/web-gl2/function-node":12,"./backend/web-gl2/kernel":13,"./backend/web-gl2/runner":14,"./core/alias":26,"./core/gpu":28,"./core/input":29,"./core/texture":30,"./core/utils":32}],34:[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';
+
+
+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"
+};
+
+
+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";
+
+var keywords = {
+  5: ecma5AndLessKeywords,
+  6: ecma5AndLessKeywords + " const class extends export import super"
+};
+
+var keywordRelationalOperator = /^in(stanceof)?$/;
+
+
+
+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\u0560-\u0588\u05d0-\u05ea\u05ef-\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\u0860-\u086a\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\u09fc\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-\u1878\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\u1c90-\u1cba\u1cbd-\u1cbf\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-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7b9\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\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\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\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\u09fe\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\u0afa-\u0aff\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-\u0c04\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\u0d00-\u0d03\u0d3b\u0d3c\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\u1cf7-\u1cf9\u1dc0-\u1df9\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\ua8ff-\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 nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,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,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,190,52,76,44,33,24,27,35,30,0,12,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,26,230,43,117,63,32,0,257,0,11,39,8,0,22,0,12,39,3,3,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,68,12,0,67,12,65,1,31,6129,15,754,9486,286,82,395,2309,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,15,7472,3104,541];
+
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,280,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,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 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 }
+  }
+}
+
+
+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)
+}
+
+
+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)
+}
+
+
+
+
+
+var TokenType = function TokenType(label, conf) {
+  if ( conf === void 0 ) conf = {};
+
+  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;
+};
+
+function binop(name, prec) {
+  return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+var beforeExpr = {beforeExpr: true};
+var startsExpr = {startsExpr: true};
+
+
+var keywords$1 = {};
+
+function kw(name, options) {
+  if ( options === void 0 ) options = {};
+
+  options.keyword = name;
+  return keywords$1[name] = new TokenType(name, options)
+}
+
+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"),
+
+  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}),
+
+
+  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}),
+
+  _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 lineBreak = /\r\n?|\n|\u2028|\u2029/;
+var lineBreakG = new RegExp(lineBreak.source, "g");
+
+function isNewLine(code, ecma2019String) {
+  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
+}
+
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+
+var ref = Object.prototype;
+var hasOwnProperty = ref.hasOwnProperty;
+var toString = ref.toString;
+
+
+function has(obj, propName) {
+  return hasOwnProperty.call(obj, propName)
+}
+
+var isArray = Array.isArray || (function (obj) { return (
+  toString.call(obj) === "[object Array]"
+); });
+
+
+var Position = function Position(line, col) {
+  this.line = line;
+  this.column = col;
+};
+
+Position.prototype.offset = function offset (n) {
+  return new Position(this.line, this.column + n)
+};
+
+var SourceLocation = function SourceLocation(p, start, end) {
+  this.start = start;
+  this.end = end;
+  if (p.sourceFile !== null) { this.source = p.sourceFile; }
+};
+
+
+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)
+    }
+  }
+}
+
+
+var defaultOptions = {
+  ecmaVersion: 7,
+  sourceType: "script",
+  onInsertedSemicolon: null,
+  onTrailingComma: null,
+  allowReserved: null,
+  allowReturnOutsideFunction: false,
+  allowImportExportEverywhere: false,
+  allowAwaitOutsideFunction: false,
+  allowHashBang: false,
+  locations: false,
+  onToken: null,
+  onComment: null,
+  ranges: false,
+  program: null,
+  sourceFile: null,
+  directSourceFile: null,
+  preserveParens: false,
+  plugins: {}
+};
+
+
+function getOptions(opts) {
+  var options = {};
+
+  for (var opt in defaultOptions)
+    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
+
+  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 options
+}
+
+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);
+  }
+}
+
+var plugins = {};
+
+function keywordRegexp(words) {
+  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
+}
+
+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);
+
+  this.containsEsc = false;
+
+  this.loadPlugins(options.plugins);
+
+
+  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;
+  }
+
+  this.type = types.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 = true;
+
+  this.inModule = options.sourceType === "module";
+  this.strict = this.inModule || this.strictDirective(this.pos);
+
+  this.potentialArrowAt = -1;
+
+  this.inFunction = this.inGenerator = this.inAsync = false;
+  this.yieldPos = this.awaitPos = 0;
+  this.labels = [];
+
+  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
+    { this.skipLineComment(2); }
+
+  this.scopeStack = [];
+  this.enterFunctionScope();
+
+  this.regexpState = null;
+};
+
+Parser.prototype.isKeyword = function isKeyword (word) { return this.keywords.test(word) };
+Parser.prototype.isReservedWord = function isReservedWord (word) { return this.reservedWords.test(word) };
+
+Parser.prototype.extend = function extend (name, f) {
+  this[name] = f(this[name]);
+};
+
+Parser.prototype.loadPlugins = function loadPlugins (pluginConfigs) {
+    var this$1 = this;
+
+  for (var name in pluginConfigs) {
+    var plugin = plugins[name];
+    if (!plugin) { throw new Error("Plugin '" + name + "' not found") }
+    plugin(this$1, pluginConfigs[name]);
+  }
+};
+
+Parser.prototype.parse = function parse () {
+  var node = this.options.program || this.startNode();
+  this.nextToken();
+  return this.parseTopLevel(node)
+};
+
+var pp = Parser.prototype;
+
+
+var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;
+pp.strictDirective = function(start) {
+  var this$1 = this;
+
+  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;
+  }
+};
+
+
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true
+  } else {
+    return false
+  }
+};
+
+
+pp.isContextual = function(name) {
+  return this.type === types.name && this.value === name && !this.containsEsc
+};
+
+
+pp.eatContextual = function(name) {
+  if (!this.isContextual(name)) { return false }
+  this.next();
+  return true
+};
+
+
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) { this.unexpected(); }
+};
+
+
+pp.canInsertSemicolon = function() {
+  return this.type === types.eof ||
+    this.type === types.braceR ||
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
+    return true
+  }
+};
+
+
+pp.semicolon = function() {
+  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+};
+
+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
+  }
+};
+
+
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
+
+
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
+
+function DestructuringErrors() {
+  this.shorthandAssign =
+  this.trailingComma =
+  this.parenthesizedAssign =
+  this.parenthesizedBind =
+  this.doubleProto =
+    -1;
+}
+
+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"); }
+};
+
+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"); }
+};
+
+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"); }
+};
+
+pp.isSimpleAssignTarget = function(expr) {
+  if (expr.type === "ParenthesizedExpression")
+    { return this.isSimpleAssignTarget(expr.expression) }
+  return expr.type === "Identifier" || expr.type === "MemberExpression"
+};
+
+var pp$1 = Parser.prototype;
+
+
+
+pp$1.parseTopLevel = function(node) {
+  var this$1 = this;
+
+  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")
+};
+
+var loopLabel = {kind: "loop"};
+var switchLabel = {kind: "switch"};
+
+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 } 
+  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
+};
+
+pp$1.isAsyncFunction = function() {
+  if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
+    { return false }
+
+  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)))
+};
+
+
+pp$1.parseStatement = function(declaration, topLevel, exports) {
+  var starttype = this.type, node = this.startNode(), kind;
+
+  if (this.isLet()) {
+    starttype = types._var;
+    kind = "let";
+  }
+
+
+  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)
+
+  default:
+    if (this.isAsyncFunction()) {
+      if (!declaration) { this.unexpected(); }
+      this.next();
+      return this.parseFunctionStatement(node, true)
+    }
+
+    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) }
+  }
+};
+
+pp$1.parseBreakContinueStatement = function(node, keyword) {
+  var this$1 = this;
+
+  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();
+  }
+
+  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")
+};
+
+pp$1.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement")
+};
+
+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")
+};
+
+
+pp$1.parseForStatement = function(node) {
+  this.next();
+  var awaitAt = (this.options.ecmaVersion >= 9 && this.inAsync && this.eatContextual("await")) ? this.lastTokStart : -1;
+  this.labels.push(loopLabel);
+  this.enterLexicalScope();
+  this.expect(types.parenL);
+  if (this.type === types.semi) {
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    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)) {
+      if (this.options.ecmaVersion >= 9) {
+        if (this.type === types._in) {
+          if (awaitAt > -1) { this.unexpected(awaitAt); }
+        } else { node.await = awaitAt > -1; }
+      }
+      return this.parseForIn(node, init$1)
+    }
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    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"))) {
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === types._in) {
+        if (awaitAt > -1) { this.unexpected(awaitAt); }
+      } else { node.await = awaitAt > -1; }
+    }
+    this.toAssignable(init, false, refDestructuringErrors);
+    this.checkLVal(init);
+    return this.parseForIn(node, init)
+  } else {
+    this.checkExpressionErrors(refDestructuringErrors, true);
+  }
+  if (awaitAt > -1) { this.unexpected(awaitAt); }
+  return this.parseFor(node, init)
+};
+
+pp$1.parseFunctionStatement = function(node, isAsync) {
+  this.next();
+  return this.parseFunction(node, true, false, isAsync)
+};
+
+pp$1.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  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")
+};
+
+pp$1.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    { this.raise(this.start, "'return' outside of function"); }
+  this.next();
+
+
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement")
+};
+
+pp$1.parseSwitchStatement = function(node) {
+  var this$1 = this;
+
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(types.braceL);
+  this.labels.push(switchLabel);
+  this.enterLexicalScope();
+
+
+  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(); 
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement")
+};
+
+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")
+};
+
+
+var empty = [];
+
+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();
+    if (this.eat(types.parenL)) {
+      clause.param = this.parseBindingAtom();
+      this.enterLexicalScope();
+      this.checkLVal(clause.param, "let");
+      this.expect(types.parenR);
+    } else {
+      if (this.options.ecmaVersion < 10) { this.unexpected(); }
+      clause.param = null;
+      this.enterLexicalScope();
+    }
+    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")
+};
+
+pp$1.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration")
+};
+
+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")
+};
+
+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")
+};
+
+pp$1.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement")
+};
+
+pp$1.parseLabeledStatement = function(node, maybeName, expr) {
+  var this$1 = this;
+
+  for (var i$1 = 0, list = this$1.labels; i$1 < list.length; i$1 += 1)
+    {
+    var label = list[i$1];
+
+    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) {
+      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")
+};
+
+pp$1.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement")
+};
+
+
+pp$1.parseBlock = function(createNewLexicalScope) {
+  var this$1 = this;
+  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
+
+  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")
+};
+
+
+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")
+};
+
+
+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)
+};
+
+
+pp$1.parseVar = function(node, isFor, kind) {
+  var this$1 = this;
+
+  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
+};
+
+pp$1.parseVarId = function(decl, kind) {
+  decl.id = this.parseBindingAtom(kind);
+  this.checkLVal(decl.id, kind, false);
+};
+
+
+pp$1.parseFunction = function(node, isStatement, allowExpressionBody, isAsync) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync)
+    { node.generator = this.eat(types.star); }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  if (isStatement) {
+    node.id = isStatement === "nullableID" && this.type !== types.name ? null : this.parseIdent();
+    if (node.id) {
+      this.checkLVal(node.id, "var");
+    }
+  }
+
+  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();
+
+  if (!isStatement)
+    { node.id = this.type === types.name ? this.parseIdent() : null; }
+
+  this.parseFunctionParams(node);
+  this.parseFunctionBody(node, allowExpressionBody);
+
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+};
+
+pp$1.parseFunctionParams = function(node) {
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+};
+
+
+pp$1.parseClass = function(node, isStatement) {
+  var this$1 = this;
+
+  this.next();
+
+  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")
+};
+
+pp$1.parseClassMember = function(classBody) {
+  var this$1 = this;
+
+  if (this.eat(types.semi)) { return null }
+
+  var method = this.startNode();
+  var tryContextual = function (k, noLineBreak) {
+    if ( noLineBreak === void 0 ) noLineBreak = false;
+
+    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
+  };
+
+  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;
+      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    } 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
+};
+
+pp$1.parseClassMethod = function(classBody, method, isGenerator, isAsync) {
+  method.value = this.parseMethod(isGenerator, isAsync);
+  classBody.body.push(this.finishNode(method, "MethodDefinition"));
+};
+
+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;
+};
+
+
+pp$1.parseExport = function(node, exports) {
+  var this$1 = this;
+
+  this.next();
+  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)) { 
+    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")
+  }
+  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 { 
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers(exports);
+    if (this.eatContextual("from")) {
+      if (this.type !== types.string) { this.unexpected(); }
+      node.source = this.parseExprAtom();
+    } else {
+      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+        var spec = list[i];
+
+        this$1.checkUnreserved(spec.local);
+      }
+
+      node.source = null;
+    }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+};
+
+pp$1.checkExport = function(exports, name, pos) {
+  if (!exports) { return }
+  if (has(exports, name))
+    { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
+  exports[name] = true;
+};
+
+pp$1.checkPatternExport = function(exports, pat) {
+  var this$1 = this;
+
+  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];
+
+        this$1.checkPatternExport(exports, prop);
+      } }
+  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 (elt) { this$1.checkPatternExport(exports, elt); }
+    } }
+  else if (type === "Property")
+    { this.checkPatternExport(exports, pat.value); }
+  else if (type === "AssignmentPattern")
+    { this.checkPatternExport(exports, pat.left); }
+  else if (type === "RestElement")
+    { this.checkPatternExport(exports, pat.argument); }
+  else if (type === "ParenthesizedExpression")
+    { this.checkPatternExport(exports, pat.expression); }
+};
+
+pp$1.checkVariableExport = function(exports, decls) {
+  var this$1 = this;
+
+  if (!exports) { return }
+  for (var i = 0, list = decls; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    this$1.checkPatternExport(exports, decl.id);
+  }
+};
+
+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()
+};
+
+
+pp$1.parseExportSpecifiers = function(exports) {
+  var this$1 = this;
+
+  var nodes = [], first = true;
+  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 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
+};
+
+
+pp$1.parseImport = function(node) {
+  this.next();
+  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")
+};
+
+
+pp$1.parseImportSpecifiers = function() {
+  var this$1 = this;
+
+  var nodes = [], first = true;
+  if (this.type === types.name) {
+    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; }
+
+    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
+};
+
+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" &&
+    (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
+  )
+};
+
+var pp$2 = Parser.prototype;
+
+
+pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+  var this$1 = this;
+
+  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
+
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "RestElement":
+      break
+
+    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];
+
+      this$1.toAssignable(prop, isBinding);
+        if (
+          prop.type === "RestElement" &&
+          (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
+        ) {
+          this$1.raise(prop.argument.start, "Unexpected token");
+        }
+      }
+      break
+
+    case "Property":
+      if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
+      this.toAssignable(node.value, isBinding);
+      break
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      this.toAssignableList(node.elements, isBinding);
+      break
+
+    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
+
+    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);
+
+    case "AssignmentPattern":
+      break
+
+    case "ParenthesizedExpression":
+      this.toAssignable(node.expression, isBinding);
+      break
+
+    case "MemberExpression":
+      if (!isBinding) { break }
+
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+  return node
+};
+
+
+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); }
+  }
+  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
+};
+
+
+pp$2.parseSpread = function(refDestructuringErrors) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+  return this.finishNode(node, "SpreadElement")
+};
+
+pp$2.parseRestBinding = function() {
+  var node = this.startNode();
+  this.next();
+
+  if (this.options.ecmaVersion === 6 && this.type !== types.name)
+    { this.unexpected(); }
+
+  node.argument = this.parseBindingAtom();
+
+  return this.finishNode(node, "RestElement")
+};
+
+
+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")
+
+    case types.braceL:
+      return this.parseObj(true)
+    }
+  }
+  return this.parseIdent()
+};
+
+pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var this$1 = this;
+
+  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
+};
+
+pp$2.parseBindingListItem = function(param) {
+  return param
+};
+
+
+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")
+};
+
+
+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 (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
+
+  case "MemberExpression":
+    if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+    break
+
+  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
+
+  case "Property":
+    this.checkLVal(expr.value, bindingType, checkClashes);
+    break
+
+  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];
+
+    if (elem) { this$1.checkLVal(elem, bindingType, checkClashes); }
+    }
+    break
+
+  case "AssignmentPattern":
+    this.checkLVal(expr.left, bindingType, checkClashes);
+    break
+
+  case "RestElement":
+    this.checkLVal(expr.argument, bindingType, checkClashes);
+    break
+
+  case "ParenthesizedExpression":
+    this.checkLVal(expr.expression, bindingType, checkClashes);
+    break
+
+  default:
+    this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
+  }
+};
+
+
+var pp$3 = Parser.prototype;
+
+
+pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
+    { return }
+  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; }
+        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;
+};
+
+
+
+
+pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+  var this$1 = this;
+
+  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
+};
+
+
+pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+  if (this.inGenerator && this.isContextual("yield")) { return this.parseYield() }
+
+  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;
+  }
+
+  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; 
+    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
+};
+
+
+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
+};
+
+
+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)
+};
+
+
+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
+};
+
+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")
+};
+
+
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+  var this$1 = this;
+
+  var startPos = this.start, startLoc = this.startLoc, expr;
+  if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
+    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");
+    }
+  }
+
+  if (!sawUnary && this.eat(types.starstar))
+    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  else
+    { return expr }
+};
+
+
+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
+};
+
+pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+  var this$1 = this;
+
+  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
+    }
+  }
+};
+
+
+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();
+    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+      { this.unexpected(); }
+    return this.finishNode(node, "Super")
+
+  case types._this:
+    node = this.startNode();
+    this.next();
+    return this.finishNode(node, "ThisExpression")
+
+  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
+
+  case types.regexp:
+    var value = this.value;
+    node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node
+
+  case types.num: case types.string:
+    return this.parseLiteral(this.value)
+
+  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")
+
+  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
+
+  case types.bracketL:
+    node = this.startNode();
+    this.next();
+    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+    return this.finishNode(node, "ArrayExpression")
+
+  case types.braceL:
+    return this.parseObj(false, refDestructuringErrors)
+
+  case types._function:
+    node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false)
+
+  case types._class:
+    return this.parseClass(this.startNode(), false)
+
+  case types._new:
+    return this.parseNew()
+
+  case types.backQuote:
+    return this.parseTemplate()
+
+  default:
+    this.unexpected();
+  }
+};
+
+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")
+};
+
+pp$3.parseParenExpression = function() {
+  this.expect(types.parenL);
+  var val = this.parseExpression();
+  this.expect(types.parenR);
+  return val
+};
+
+pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+  var this$1 = this;
+
+  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
+
+    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 (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 (!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 {
+      val = exprList[0];
+    }
+  } else {
+    val = this.parseParenExpression();
+  }
+
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(startPos, startLoc);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression")
+  } else {
+    return val
+  }
+};
+
+pp$3.parseParenItem = function(item) {
+  return item
+};
+
+pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+};
+
+
+var empty$1 = [];
+
+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")
+};
+
+
+pp$3.parseTemplateElement = function(ref) {
+  var isTagged = ref.isTagged;
+
+  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")
+};
+
+pp$3.parseTemplate = function(ref) {
+  var this$1 = this;
+  if ( ref === void 0 ) ref = {};
+  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
+
+  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")
+};
+
+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 || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
+    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+
+pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+  var this$1 = this;
+
+  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 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")
+};
+
+pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
+  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
+  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
+    if (isPattern) {
+      prop.argument = this.parseIdent(false);
+      if (this.type === types.comma) {
+        this.raise(this.start, "Comma is not permitted after the rest element");
+      }
+      return this.finishNode(prop, "RestElement")
+    }
+    if (this.type === types.parenL && refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0) {
+        refDestructuringErrors.parenthesizedAssign = this.start;
+      }
+      if (refDestructuringErrors.parenthesizedBind < 0) {
+        refDestructuringErrors.parenthesizedBind = this.start;
+      }
+    }
+    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
+      refDestructuringErrors.trailingComma = this.start;
+    }
+    return this.finishNode(prop, "SpreadElement")
+  }
+  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;
+    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    this.parsePropertyName(prop, refDestructuringErrors);
+  } else {
+    isAsync = false;
+  }
+  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
+  return this.finishNode(prop, "Property")
+};
+
+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(); }
+};
+
+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)
+};
+
+
+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; }
+};
+
+
+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;
+
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6)
+    { node.generator = isGenerator; }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  this.inGenerator = node.generator;
+  this.inAsync = node.async;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.inFunction = true;
+  this.enterFunctionScope();
+
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+  this.parseFunctionBody(node, false);
+
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, "FunctionExpression")
+};
+
+
+pp$3.parseArrowExpression = function(node, params, isAsync) {
+  var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
+      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
+
+  this.enterFunctionScope();
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  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);
+
+  this.inGenerator = oldInGen;
+  this.inAsync = oldInAsync;
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.inFunction = oldInFunc;
+  return this.finishNode(node, "ArrowFunctionExpression")
+};
+
+
+pp$3.parseFunctionBody = function(node, isArrowFunction) {
+  var isExpression = isArrowFunction && this.type !== types.braceL;
+  var oldStrict = this.strict, useStrict = false;
+
+  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 (useStrict && nonSimple)
+        { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
+    }
+    var oldLabels = this.labels;
+    this.labels = [];
+    if (useStrict) { this.strict = true; }
+
+    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();
+
+  if (this.strict && node.id) {
+    this.checkLVal(node.id, "none");
+  }
+  this.strict = oldStrict;
+};
+
+pp$3.isSimpleParamList = function(params) {
+  for (var i = 0, list = params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    if (param.type !== "Identifier") { return false
+  } }
+  return true
+};
+
+
+pp$3.checkParams = function(node, allowDuplicates) {
+  var this$1 = this;
+
+  var nameHash = {};
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    this$1.checkLVal(param, "var", allowDuplicates ? null : nameHash);
+  }
+};
+
+
+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; }
+
+    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
+};
+
+pp$3.checkUnreserved = function(ref) {
+  var start = ref.start;
+  var end = ref.end;
+  var name = ref.name;
+
+  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"));
+  }
+};
+
+
+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;
+
+    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
+};
+
+
+pp$3.parseYield = function() {
+  if (!this.yieldPos) { this.yieldPos = this.start; }
+
+  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")
+};
+
+pp$3.parseAwait = function() {
+  if (!this.awaitPos) { this.awaitPos = this.start; }
+
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeUnary(null, true);
+  return this.finishNode(node, "AwaitExpression")
+};
+
+var pp$4 = Parser.prototype;
+
+
+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
+};
+
+pp$4.raiseRecoverable = pp$4.raise;
+
+pp$4.curPosition = function() {
+  if (this.options.locations) {
+    return new Position(this.curLine, this.pos - this.lineStart)
+  }
+};
+
+var pp$5 = Parser.prototype;
+
+var assign = Object.assign || function(target) {
+  var sources = [], len = arguments.length - 1;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
+
+  for (var i = 0, list = sources; i < list.length; i += 1) {
+    var source = list[i];
+
+    for (var key in source) {
+      if (has(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target
+};
+
+
+pp$5.enterFunctionScope = function() {
+  this.scopeStack.push({var: {}, lexical: {}, childVar: {}, parentLexical: {}});
+};
+
+pp$5.exitFunctionScope = function() {
+  this.scopeStack.pop();
+};
+
+pp$5.enterLexicalScope = function() {
+  var parentScope = this.scopeStack[this.scopeStack.length - 1];
+  var childScope = {var: {}, lexical: {}, childVar: {}, parentLexical: {}};
+
+  this.scopeStack.push(childScope);
+  assign(childScope.parentLexical, parentScope.lexical, parentScope.parentLexical);
+};
+
+pp$5.exitLexicalScope = function() {
+  var childScope = this.scopeStack.pop();
+  var parentScope = this.scopeStack[this.scopeStack.length - 1];
+
+  assign(parentScope.childVar, childScope.var, childScope.childVar);
+};
+
+pp$5.canDeclareVarName = function(name) {
+  var currentScope = this.scopeStack[this.scopeStack.length - 1];
+
+  return !has(currentScope.lexical, name) && !has(currentScope.parentLexical, name)
+};
+
+pp$5.canDeclareLexicalName = function(name) {
+  var currentScope = this.scopeStack[this.scopeStack.length - 1];
+
+  return !has(currentScope.lexical, name) && !has(currentScope.var, name) && !has(currentScope.childVar, name)
+};
+
+pp$5.declareVarName = function(name) {
+  this.scopeStack[this.scopeStack.length - 1].var[name] = true;
+};
+
+pp$5.declareLexicalName = function(name) {
+  this.scopeStack[this.scopeStack.length - 1].lexical[name] = true;
+};
+
+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]; }
+};
+
+
+var pp$6 = Parser.prototype;
+
+pp$6.startNode = function() {
+  return new Node(this, this.start, this.startLoc)
+};
+
+pp$6.startNodeAt = function(pos, loc) {
+  return new Node(this, pos, loc)
+};
+
+
+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
+}
+
+pp$6.finishNode = function(node, type) {
+  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+};
+
+
+pp$6.finishNodeAt = function(node, type, pos, loc) {
+  return finishNodeAt.call(this, node, type, pos, loc)
+};
+
+
+var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
+  this.token = token;
+  this.isExpr = !!isExpr;
+  this.preserveSpace = !!preserveSpace;
+  this.override = override;
+  this.generator = !!generator;
+};
+
+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)
+};
+
+var pp$7 = Parser.prototype;
+
+pp$7.initialContext = function() {
+  return [types$1.b_stat]
+};
+
+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 }
+
+  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
+};
+
+pp$7.inGeneratorContext = function() {
+  var this$1 = this;
+
+  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
+};
+
+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; }
+};
+
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+types.incDec.updateContext = function() {
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+var data = {
+  "$LONE": [
+    "ASCII",
+    "ASCII_Hex_Digit",
+    "AHex",
+    "Alphabetic",
+    "Alpha",
+    "Any",
+    "Assigned",
+    "Bidi_Control",
+    "Bidi_C",
+    "Bidi_Mirrored",
+    "Bidi_M",
+    "Case_Ignorable",
+    "CI",
+    "Cased",
+    "Changes_When_Casefolded",
+    "CWCF",
+    "Changes_When_Casemapped",
+    "CWCM",
+    "Changes_When_Lowercased",
+    "CWL",
+    "Changes_When_NFKC_Casefolded",
+    "CWKCF",
+    "Changes_When_Titlecased",
+    "CWT",
+    "Changes_When_Uppercased",
+    "CWU",
+    "Dash",
+    "Default_Ignorable_Code_Point",
+    "DI",
+    "Deprecated",
+    "Dep",
+    "Diacritic",
+    "Dia",
+    "Emoji",
+    "Emoji_Component",
+    "Emoji_Modifier",
+    "Emoji_Modifier_Base",
+    "Emoji_Presentation",
+    "Extender",
+    "Ext",
+    "Grapheme_Base",
+    "Gr_Base",
+    "Grapheme_Extend",
+    "Gr_Ext",
+    "Hex_Digit",
+    "Hex",
+    "IDS_Binary_Operator",
+    "IDSB",
+    "IDS_Trinary_Operator",
+    "IDST",
+    "ID_Continue",
+    "IDC",
+    "ID_Start",
+    "IDS",
+    "Ideographic",
+    "Ideo",
+    "Join_Control",
+    "Join_C",
+    "Logical_Order_Exception",
+    "LOE",
+    "Lowercase",
+    "Lower",
+    "Math",
+    "Noncharacter_Code_Point",
+    "NChar",
+    "Pattern_Syntax",
+    "Pat_Syn",
+    "Pattern_White_Space",
+    "Pat_WS",
+    "Quotation_Mark",
+    "QMark",
+    "Radical",
+    "Regional_Indicator",
+    "RI",
+    "Sentence_Terminal",
+    "STerm",
+    "Soft_Dotted",
+    "SD",
+    "Terminal_Punctuation",
+    "Term",
+    "Unified_Ideograph",
+    "UIdeo",
+    "Uppercase",
+    "Upper",
+    "Variation_Selector",
+    "VS",
+    "White_Space",
+    "space",
+    "XID_Continue",
+    "XIDC",
+    "XID_Start",
+    "XIDS"
+  ],
+  "General_Category": [
+    "Cased_Letter",
+    "LC",
+    "Close_Punctuation",
+    "Pe",
+    "Connector_Punctuation",
+    "Pc",
+    "Control",
+    "Cc",
+    "cntrl",
+    "Currency_Symbol",
+    "Sc",
+    "Dash_Punctuation",
+    "Pd",
+    "Decimal_Number",
+    "Nd",
+    "digit",
+    "Enclosing_Mark",
+    "Me",
+    "Final_Punctuation",
+    "Pf",
+    "Format",
+    "Cf",
+    "Initial_Punctuation",
+    "Pi",
+    "Letter",
+    "L",
+    "Letter_Number",
+    "Nl",
+    "Line_Separator",
+    "Zl",
+    "Lowercase_Letter",
+    "Ll",
+    "Mark",
+    "M",
+    "Combining_Mark",
+    "Math_Symbol",
+    "Sm",
+    "Modifier_Letter",
+    "Lm",
+    "Modifier_Symbol",
+    "Sk",
+    "Nonspacing_Mark",
+    "Mn",
+    "Number",
+    "N",
+    "Open_Punctuation",
+    "Ps",
+    "Other",
+    "C",
+    "Other_Letter",
+    "Lo",
+    "Other_Number",
+    "No",
+    "Other_Punctuation",
+    "Po",
+    "Other_Symbol",
+    "So",
+    "Paragraph_Separator",
+    "Zp",
+    "Private_Use",
+    "Co",
+    "Punctuation",
+    "P",
+    "punct",
+    "Separator",
+    "Z",
+    "Space_Separator",
+    "Zs",
+    "Spacing_Mark",
+    "Mc",
+    "Surrogate",
+    "Cs",
+    "Symbol",
+    "S",
+    "Titlecase_Letter",
+    "Lt",
+    "Unassigned",
+    "Cn",
+    "Uppercase_Letter",
+    "Lu"
+  ],
+  "Script": [
+    "Adlam",
+    "Adlm",
+    "Ahom",
+    "Anatolian_Hieroglyphs",
+    "Hluw",
+    "Arabic",
+    "Arab",
+    "Armenian",
+    "Armn",
+    "Avestan",
+    "Avst",
+    "Balinese",
+    "Bali",
+    "Bamum",
+    "Bamu",
+    "Bassa_Vah",
+    "Bass",
+    "Batak",
+    "Batk",
+    "Bengali",
+    "Beng",
+    "Bhaiksuki",
+    "Bhks",
+    "Bopomofo",
+    "Bopo",
+    "Brahmi",
+    "Brah",
+    "Braille",
+    "Brai",
+    "Buginese",
+    "Bugi",
+    "Buhid",
+    "Buhd",
+    "Canadian_Aboriginal",
+    "Cans",
+    "Carian",
+    "Cari",
+    "Caucasian_Albanian",
+    "Aghb",
+    "Chakma",
+    "Cakm",
+    "Cham",
+    "Cherokee",
+    "Cher",
+    "Common",
+    "Zyyy",
+    "Coptic",
+    "Copt",
+    "Qaac",
+    "Cuneiform",
+    "Xsux",
+    "Cypriot",
+    "Cprt",
+    "Cyrillic",
+    "Cyrl",
+    "Deseret",
+    "Dsrt",
+    "Devanagari",
+    "Deva",
+    "Duployan",
+    "Dupl",
+    "Egyptian_Hieroglyphs",
+    "Egyp",
+    "Elbasan",
+    "Elba",
+    "Ethiopic",
+    "Ethi",
+    "Georgian",
+    "Geor",
+    "Glagolitic",
+    "Glag",
+    "Gothic",
+    "Goth",
+    "Grantha",
+    "Gran",
+    "Greek",
+    "Grek",
+    "Gujarati",
+    "Gujr",
+    "Gurmukhi",
+    "Guru",
+    "Han",
+    "Hani",
+    "Hangul",
+    "Hang",
+    "Hanunoo",
+    "Hano",
+    "Hatran",
+    "Hatr",
+    "Hebrew",
+    "Hebr",
+    "Hiragana",
+    "Hira",
+    "Imperial_Aramaic",
+    "Armi",
+    "Inherited",
+    "Zinh",
+    "Qaai",
+    "Inscriptional_Pahlavi",
+    "Phli",
+    "Inscriptional_Parthian",
+    "Prti",
+    "Javanese",
+    "Java",
+    "Kaithi",
+    "Kthi",
+    "Kannada",
+    "Knda",
+    "Katakana",
+    "Kana",
+    "Kayah_Li",
+    "Kali",
+    "Kharoshthi",
+    "Khar",
+    "Khmer",
+    "Khmr",
+    "Khojki",
+    "Khoj",
+    "Khudawadi",
+    "Sind",
+    "Lao",
+    "Laoo",
+    "Latin",
+    "Latn",
+    "Lepcha",
+    "Lepc",
+    "Limbu",
+    "Limb",
+    "Linear_A",
+    "Lina",
+    "Linear_B",
+    "Linb",
+    "Lisu",
+    "Lycian",
+    "Lyci",
+    "Lydian",
+    "Lydi",
+    "Mahajani",
+    "Mahj",
+    "Malayalam",
+    "Mlym",
+    "Mandaic",
+    "Mand",
+    "Manichaean",
+    "Mani",
+    "Marchen",
+    "Marc",
+    "Masaram_Gondi",
+    "Gonm",
+    "Meetei_Mayek",
+    "Mtei",
+    "Mende_Kikakui",
+    "Mend",
+    "Meroitic_Cursive",
+    "Merc",
+    "Meroitic_Hieroglyphs",
+    "Mero",
+    "Miao",
+    "Plrd",
+    "Modi",
+    "Mongolian",
+    "Mong",
+    "Mro",
+    "Mroo",
+    "Multani",
+    "Mult",
+    "Myanmar",
+    "Mymr",
+    "Nabataean",
+    "Nbat",
+    "New_Tai_Lue",
+    "Talu",
+    "Newa",
+    "Nko",
+    "Nkoo",
+    "Nushu",
+    "Nshu",
+    "Ogham",
+    "Ogam",
+    "Ol_Chiki",
+    "Olck",
+    "Old_Hungarian",
+    "Hung",
+    "Old_Italic",
+    "Ital",
+    "Old_North_Arabian",
+    "Narb",
+    "Old_Permic",
+    "Perm",
+    "Old_Persian",
+    "Xpeo",
+    "Old_South_Arabian",
+    "Sarb",
+    "Old_Turkic",
+    "Orkh",
+    "Oriya",
+    "Orya",
+    "Osage",
+    "Osge",
+    "Osmanya",
+    "Osma",
+    "Pahawh_Hmong",
+    "Hmng",
+    "Palmyrene",
+    "Palm",
+    "Pau_Cin_Hau",
+    "Pauc",
+    "Phags_Pa",
+    "Phag",
+    "Phoenician",
+    "Phnx",
+    "Psalter_Pahlavi",
+    "Phlp",
+    "Rejang",
+    "Rjng",
+    "Runic",
+    "Runr",
+    "Samaritan",
+    "Samr",
+    "Saurashtra",
+    "Saur",
+    "Sharada",
+    "Shrd",
+    "Shavian",
+    "Shaw",
+    "Siddham",
+    "Sidd",
+    "SignWriting",
+    "Sgnw",
+    "Sinhala",
+    "Sinh",
+    "Sora_Sompeng",
+    "Sora",
+    "Soyombo",
+    "Soyo",
+    "Sundanese",
+    "Sund",
+    "Syloti_Nagri",
+    "Sylo",
+    "Syriac",
+    "Syrc",
+    "Tagalog",
+    "Tglg",
+    "Tagbanwa",
+    "Tagb",
+    "Tai_Le",
+    "Tale",
+    "Tai_Tham",
+    "Lana",
+    "Tai_Viet",
+    "Tavt",
+    "Takri",
+    "Takr",
+    "Tamil",
+    "Taml",
+    "Tangut",
+    "Tang",
+    "Telugu",
+    "Telu",
+    "Thaana",
+    "Thaa",
+    "Thai",
+    "Tibetan",
+    "Tibt",
+    "Tifinagh",
+    "Tfng",
+    "Tirhuta",
+    "Tirh",
+    "Ugaritic",
+    "Ugar",
+    "Vai",
+    "Vaii",
+    "Warang_Citi",
+    "Wara",
+    "Yi",
+    "Yiii",
+    "Zanabazar_Square",
+    "Zanb"
+  ]
+};
+Array.prototype.push.apply(data.$LONE, data.General_Category);
+data.gc = data.General_Category;
+data.sc = data.Script_Extensions = data.scx = data.Script;
+
+var pp$9 = Parser.prototype;
+
+var RegExpValidationState = function RegExpValidationState(parser) {
+  this.parser = parser;
+  this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
+  this.source = "";
+  this.flags = "";
+  this.start = 0;
+  this.switchU = false;
+  this.switchN = false;
+  this.pos = 0;
+  this.lastIntValue = 0;
+  this.lastStringValue = "";
+  this.lastAssertionIsQuantifiable = false;
+  this.numCapturingParens = 0;
+  this.maxBackReference = 0;
+  this.groupNames = [];
+  this.backReferenceNames = [];
+};
+
+RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
+  var unicode = flags.indexOf("u") !== -1;
+  this.start = start | 0;
+  this.source = pattern + "";
+  this.flags = flags;
+  this.switchU = unicode && this.parser.options.ecmaVersion >= 6;
+  this.switchN = unicode && this.parser.options.ecmaVersion >= 9;
+};
+
+RegExpValidationState.prototype.raise = function raise (message) {
+  this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message));
+};
+
+RegExpValidationState.prototype.at = function at (i) {
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return -1
+  }
+  var c = s.charCodeAt(i);
+  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+    return c
+  }
+  return (c << 10) + s.charCodeAt(i + 1) - 0x35FDC00
+};
+
+RegExpValidationState.prototype.nextIndex = function nextIndex (i) {
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return l
+  }
+  var c = s.charCodeAt(i);
+  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+    return i + 1
+  }
+  return i + 2
+};
+
+RegExpValidationState.prototype.current = function current () {
+  return this.at(this.pos)
+};
+
+RegExpValidationState.prototype.lookahead = function lookahead () {
+  return this.at(this.nextIndex(this.pos))
+};
+
+RegExpValidationState.prototype.advance = function advance () {
+  this.pos = this.nextIndex(this.pos);
+};
+
+RegExpValidationState.prototype.eat = function eat (ch) {
+  if (this.current() === ch) {
+    this.advance();
+    return true
+  }
+  return false
+};
+
+function codePointToString$1(ch) {
+  if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
+  ch -= 0x10000;
+  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
+}
+
+pp$9.validateRegExpFlags = function(state) {
+  var this$1 = this;
+
+  var validFlags = state.validFlags;
+  var flags = state.flags;
+
+  for (var i = 0; i < flags.length; i++) {
+    var flag = flags.charAt(i);
+    if (validFlags.indexOf(flag) === -1) {
+      this$1.raise(state.start, "Invalid regular expression flag");
+    }
+    if (flags.indexOf(flag, i + 1) > -1) {
+      this$1.raise(state.start, "Duplicate regular expression flag");
+    }
+  }
+};
+
+pp$9.validateRegExpPattern = function(state) {
+  this.regexp_pattern(state);
+
+  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
+    state.switchN = true;
+    this.regexp_pattern(state);
+  }
+};
+
+pp$9.regexp_pattern = function(state) {
+  state.pos = 0;
+  state.lastIntValue = 0;
+  state.lastStringValue = "";
+  state.lastAssertionIsQuantifiable = false;
+  state.numCapturingParens = 0;
+  state.maxBackReference = 0;
+  state.groupNames.length = 0;
+  state.backReferenceNames.length = 0;
+
+  this.regexp_disjunction(state);
+
+  if (state.pos !== state.source.length) {
+    if (state.eat(0x29 )) {
+      state.raise("Unmatched ')'");
+    }
+    if (state.eat(0x5D ) || state.eat(0x7D )) {
+      state.raise("Lone quantifier brackets");
+    }
+  }
+  if (state.maxBackReference > state.numCapturingParens) {
+    state.raise("Invalid escape");
+  }
+  for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
+    var name = list[i];
+
+    if (state.groupNames.indexOf(name) === -1) {
+      state.raise("Invalid named capture referenced");
+    }
+  }
+};
+
+pp$9.regexp_disjunction = function(state) {
+  var this$1 = this;
+
+  this.regexp_alternative(state);
+  while (state.eat(0x7C )) {
+    this$1.regexp_alternative(state);
+  }
+
+  if (this.regexp_eatQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  if (state.eat(0x7B )) {
+    state.raise("Lone quantifier brackets");
+  }
+};
+
+pp$9.regexp_alternative = function(state) {
+  while (state.pos < state.source.length && this.regexp_eatTerm(state))
+    {  }
+};
+
+pp$9.regexp_eatTerm = function(state) {
+  if (this.regexp_eatAssertion(state)) {
+    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
+      if (state.switchU) {
+        state.raise("Invalid quantifier");
+      }
+    }
+    return true
+  }
+
+  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
+    this.regexp_eatQuantifier(state);
+    return true
+  }
+
+  return false
+};
+
+pp$9.regexp_eatAssertion = function(state) {
+  var start = state.pos;
+  state.lastAssertionIsQuantifiable = false;
+
+  if (state.eat(0x5E ) || state.eat(0x24 )) {
+    return true
+  }
+
+  if (state.eat(0x5C )) {
+    if (state.eat(0x42 ) || state.eat(0x62 )) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  if (state.eat(0x28 ) && state.eat(0x3F )) {
+    var lookbehind = false;
+    if (this.options.ecmaVersion >= 9) {
+      lookbehind = state.eat(0x3C );
+    }
+    if (state.eat(0x3D ) || state.eat(0x21 )) {
+      this.regexp_disjunction(state);
+      if (!state.eat(0x29 )) {
+        state.raise("Unterminated group");
+      }
+      state.lastAssertionIsQuantifiable = !lookbehind;
+      return true
+    }
+  }
+
+  state.pos = start;
+  return false
+};
+
+pp$9.regexp_eatQuantifier = function(state, noError) {
+  if ( noError === void 0 ) noError = false;
+
+  if (this.regexp_eatQuantifierPrefix(state, noError)) {
+    state.eat(0x3F );
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatQuantifierPrefix = function(state, noError) {
+  return (
+    state.eat(0x2A ) ||
+    state.eat(0x2B ) ||
+    state.eat(0x3F ) ||
+    this.regexp_eatBracedQuantifier(state, noError)
+  )
+};
+pp$9.regexp_eatBracedQuantifier = function(state, noError) {
+  var start = state.pos;
+  if (state.eat(0x7B )) {
+    var min = 0, max = -1;
+    if (this.regexp_eatDecimalDigits(state)) {
+      min = state.lastIntValue;
+      if (state.eat(0x2C ) && this.regexp_eatDecimalDigits(state)) {
+        max = state.lastIntValue;
+      }
+      if (state.eat(0x7D )) {
+        if (max !== -1 && max < min && !noError) {
+          state.raise("numbers out of order in {} quantifier");
+        }
+        return true
+      }
+    }
+    if (state.switchU && !noError) {
+      state.raise("Incomplete quantifier");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+pp$9.regexp_eatAtom = function(state) {
+  return (
+    this.regexp_eatPatternCharacters(state) ||
+    state.eat(0x2E ) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state)
+  )
+};
+pp$9.regexp_eatReverseSolidusAtomEscape = function(state) {
+  var start = state.pos;
+  if (state.eat(0x5C )) {
+    if (this.regexp_eatAtomEscape(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$9.regexp_eatUncapturingGroup = function(state) {
+  var start = state.pos;
+  if (state.eat(0x28 )) {
+    if (state.eat(0x3F ) && state.eat(0x3A )) {
+      this.regexp_disjunction(state);
+      if (state.eat(0x29 )) {
+        return true
+      }
+      state.raise("Unterminated group");
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$9.regexp_eatCapturingGroup = function(state) {
+  if (state.eat(0x28 )) {
+    if (this.options.ecmaVersion >= 9) {
+      this.regexp_groupSpecifier(state);
+    } else if (state.current() === 0x3F ) {
+      state.raise("Invalid group");
+    }
+    this.regexp_disjunction(state);
+    if (state.eat(0x29 )) {
+      state.numCapturingParens += 1;
+      return true
+    }
+    state.raise("Unterminated group");
+  }
+  return false
+};
+
+pp$9.regexp_eatExtendedAtom = function(state) {
+  return (
+    state.eat(0x2E ) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state) ||
+    this.regexp_eatInvalidBracedQuantifier(state) ||
+    this.regexp_eatExtendedPatternCharacter(state)
+  )
+};
+
+pp$9.regexp_eatInvalidBracedQuantifier = function(state) {
+  if (this.regexp_eatBracedQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  return false
+};
+
+pp$9.regexp_eatSyntaxCharacter = function(state) {
+  var ch = state.current();
+  if (isSyntaxCharacter(ch)) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isSyntaxCharacter(ch) {
+  return (
+    ch === 0x24  ||
+    ch >= 0x28  && ch <= 0x2B  ||
+    ch === 0x2E  ||
+    ch === 0x3F  ||
+    ch >= 0x5B  && ch <= 0x5E  ||
+    ch >= 0x7B  && ch <= 0x7D 
+  )
+}
+
+pp$9.regexp_eatPatternCharacters = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
+    state.advance();
+  }
+  return state.pos !== start
+};
+
+pp$9.regexp_eatExtendedPatternCharacter = function(state) {
+  var ch = state.current();
+  if (
+    ch !== -1 &&
+    ch !== 0x24  &&
+    !(ch >= 0x28  && ch <= 0x2B ) &&
+    ch !== 0x2E  &&
+    ch !== 0x3F  &&
+    ch !== 0x5B  &&
+    ch !== 0x5E  &&
+    ch !== 0x7C 
+  ) {
+    state.advance();
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_groupSpecifier = function(state) {
+  if (state.eat(0x3F )) {
+    if (this.regexp_eatGroupName(state)) {
+      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
+        state.raise("Duplicate capture group name");
+      }
+      state.groupNames.push(state.lastStringValue);
+      return
+    }
+    state.raise("Invalid group");
+  }
+};
+
+pp$9.regexp_eatGroupName = function(state) {
+  state.lastStringValue = "";
+  if (state.eat(0x3C )) {
+    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E )) {
+      return true
+    }
+    state.raise("Invalid capture group name");
+  }
+  return false
+};
+
+pp$9.regexp_eatRegExpIdentifierName = function(state) {
+  state.lastStringValue = "";
+  if (this.regexp_eatRegExpIdentifierStart(state)) {
+    state.lastStringValue += codePointToString$1(state.lastIntValue);
+    while (this.regexp_eatRegExpIdentifierPart(state)) {
+      state.lastStringValue += codePointToString$1(state.lastIntValue);
+    }
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatRegExpIdentifierStart = function(state) {
+  var start = state.pos;
+  var ch = state.current();
+  state.advance();
+
+  if (ch === 0x5C  && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierStart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierStart(ch) {
+  return isIdentifierStart(ch, true) || ch === 0x24  || ch === 0x5F 
+}
+
+pp$9.regexp_eatRegExpIdentifierPart = function(state) {
+  var start = state.pos;
+  var ch = state.current();
+  state.advance();
+
+  if (ch === 0x5C  && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierPart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierPart(ch) {
+  return isIdentifierChar(ch, true) || ch === 0x24  || ch === 0x5F  || ch === 0x200C  || ch === 0x200D 
+}
+
+pp$9.regexp_eatAtomEscape = function(state) {
+  if (
+    this.regexp_eatBackReference(state) ||
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state) ||
+    (state.switchN && this.regexp_eatKGroupName(state))
+  ) {
+    return true
+  }
+  if (state.switchU) {
+    if (state.current() === 0x63 ) {
+      state.raise("Invalid unicode escape");
+    }
+    state.raise("Invalid escape");
+  }
+  return false
+};
+pp$9.regexp_eatBackReference = function(state) {
+  var start = state.pos;
+  if (this.regexp_eatDecimalEscape(state)) {
+    var n = state.lastIntValue;
+    if (state.switchU) {
+      if (n > state.maxBackReference) {
+        state.maxBackReference = n;
+      }
+      return true
+    }
+    if (n <= state.numCapturingParens) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$9.regexp_eatKGroupName = function(state) {
+  if (state.eat(0x6B )) {
+    if (this.regexp_eatGroupName(state)) {
+      state.backReferenceNames.push(state.lastStringValue);
+      return true
+    }
+    state.raise("Invalid named reference");
+  }
+  return false
+};
+
+pp$9.regexp_eatCharacterEscape = function(state) {
+  return (
+    this.regexp_eatControlEscape(state) ||
+    this.regexp_eatCControlLetter(state) ||
+    this.regexp_eatZero(state) ||
+    this.regexp_eatHexEscapeSequence(state) ||
+    this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
+    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
+    this.regexp_eatIdentityEscape(state)
+  )
+};
+pp$9.regexp_eatCControlLetter = function(state) {
+  var start = state.pos;
+  if (state.eat(0x63 )) {
+    if (this.regexp_eatControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$9.regexp_eatZero = function(state) {
+  if (state.current() === 0x30  && !isDecimalDigit(state.lookahead())) {
+    state.lastIntValue = 0;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatControlEscape = function(state) {
+  var ch = state.current();
+  if (ch === 0x74 ) {
+    state.lastIntValue = 0x09; 
+    state.advance();
+    return true
+  }
+  if (ch === 0x6E ) {
+    state.lastIntValue = 0x0A; 
+    state.advance();
+    return true
+  }
+  if (ch === 0x76 ) {
+    state.lastIntValue = 0x0B; 
+    state.advance();
+    return true
+  }
+  if (ch === 0x66 ) {
+    state.lastIntValue = 0x0C; 
+    state.advance();
+    return true
+  }
+  if (ch === 0x72 ) {
+    state.lastIntValue = 0x0D; 
+    state.advance();
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatControlLetter = function(state) {
+  var ch = state.current();
+  if (isControlLetter(ch)) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isControlLetter(ch) {
+  return (
+    (ch >= 0x41  && ch <= 0x5A ) ||
+    (ch >= 0x61  && ch <= 0x7A )
+  )
+}
+
+pp$9.regexp_eatRegExpUnicodeEscapeSequence = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x75 )) {
+    if (this.regexp_eatFixedHexDigits(state, 4)) {
+      var lead = state.lastIntValue;
+      if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
+        var leadSurrogateEnd = state.pos;
+        if (state.eat(0x5C ) && state.eat(0x75 ) && this.regexp_eatFixedHexDigits(state, 4)) {
+          var trail = state.lastIntValue;
+          if (trail >= 0xDC00 && trail <= 0xDFFF) {
+            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+            return true
+          }
+        }
+        state.pos = leadSurrogateEnd;
+        state.lastIntValue = lead;
+      }
+      return true
+    }
+    if (
+      state.switchU &&
+      state.eat(0x7B ) &&
+      this.regexp_eatHexDigits(state) &&
+      state.eat(0x7D ) &&
+      isValidUnicode(state.lastIntValue)
+    ) {
+      return true
+    }
+    if (state.switchU) {
+      state.raise("Invalid unicode escape");
+    }
+    state.pos = start;
+  }
+
+  return false
+};
+function isValidUnicode(ch) {
+  return ch >= 0 && ch <= 0x10FFFF
+}
+
+pp$9.regexp_eatIdentityEscape = function(state) {
+  if (state.switchU) {
+    if (this.regexp_eatSyntaxCharacter(state)) {
+      return true
+    }
+    if (state.eat(0x2F )) {
+      state.lastIntValue = 0x2F; 
+      return true
+    }
+    return false
+  }
+
+  var ch = state.current();
+  if (ch !== 0x63  && (!state.switchN || ch !== 0x6B )) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+pp$9.regexp_eatDecimalEscape = function(state) {
+  state.lastIntValue = 0;
+  var ch = state.current();
+  if (ch >= 0x31  && ch <= 0x39 ) {
+    do {
+      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 );
+      state.advance();
+    } while ((ch = state.current()) >= 0x30  && ch <= 0x39 )
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatCharacterClassEscape = function(state) {
+  var ch = state.current();
+
+  if (isCharacterClassEscape(ch)) {
+    state.lastIntValue = -1;
+    state.advance();
+    return true
+  }
+
+  if (
+    state.switchU &&
+    this.options.ecmaVersion >= 9 &&
+    (ch === 0x50  || ch === 0x70 )
+  ) {
+    state.lastIntValue = -1;
+    state.advance();
+    if (
+      state.eat(0x7B ) &&
+      this.regexp_eatUnicodePropertyValueExpression(state) &&
+      state.eat(0x7D )
+    ) {
+      return true
+    }
+    state.raise("Invalid property name");
+  }
+
+  return false
+};
+function isCharacterClassEscape(ch) {
+  return (
+    ch === 0x64  ||
+    ch === 0x44  ||
+    ch === 0x73  ||
+    ch === 0x53  ||
+    ch === 0x77  ||
+    ch === 0x57 
+  )
+}
+
+pp$9.regexp_eatUnicodePropertyValueExpression = function(state) {
+  var start = state.pos;
+
+  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D )) {
+    var name = state.lastStringValue;
+    if (this.regexp_eatUnicodePropertyValue(state)) {
+      var value = state.lastStringValue;
+      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
+      return true
+    }
+  }
+  state.pos = start;
+
+  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
+    var nameOrValue = state.lastStringValue;
+    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
+    return true
+  }
+  return false
+};
+pp$9.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+  if (!data.hasOwnProperty(name) || data[name].indexOf(value) === -1) {
+    state.raise("Invalid property name");
+  }
+};
+pp$9.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
+  if (data.$LONE.indexOf(nameOrValue) === -1) {
+    state.raise("Invalid property name");
+  }
+};
+
+pp$9.regexp_eatUnicodePropertyName = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyNameCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString$1(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyNameCharacter(ch) {
+  return isControlLetter(ch) || ch === 0x5F 
+}
+
+pp$9.regexp_eatUnicodePropertyValue = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyValueCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString$1(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyValueCharacter(ch) {
+  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
+}
+
+pp$9.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
+  return this.regexp_eatUnicodePropertyValue(state)
+};
+
+pp$9.regexp_eatCharacterClass = function(state) {
+  if (state.eat(0x5B )) {
+    state.eat(0x5E );
+    this.regexp_classRanges(state);
+    if (state.eat(0x5D )) {
+      return true
+    }
+    state.raise("Unterminated character class");
+  }
+  return false
+};
+
+pp$9.regexp_classRanges = function(state) {
+  var this$1 = this;
+
+  while (this.regexp_eatClassAtom(state)) {
+    var left = state.lastIntValue;
+    if (state.eat(0x2D ) && this$1.regexp_eatClassAtom(state)) {
+      var right = state.lastIntValue;
+      if (state.switchU && (left === -1 || right === -1)) {
+        state.raise("Invalid character class");
+      }
+      if (left !== -1 && right !== -1 && left > right) {
+        state.raise("Range out of order in character class");
+      }
+    }
+  }
+};
+
+pp$9.regexp_eatClassAtom = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x5C )) {
+    if (this.regexp_eatClassEscape(state)) {
+      return true
+    }
+    if (state.switchU) {
+      var ch$1 = state.current();
+      if (ch$1 === 0x63  || isOctalDigit(ch$1)) {
+        state.raise("Invalid class escape");
+      }
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+
+  var ch = state.current();
+  if (ch !== 0x5D ) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+pp$9.regexp_eatClassEscape = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x62 )) {
+    state.lastIntValue = 0x08; 
+    return true
+  }
+
+  if (state.switchU && state.eat(0x2D )) {
+    state.lastIntValue = 0x2D; 
+    return true
+  }
+
+  if (!state.switchU && state.eat(0x63 )) {
+    if (this.regexp_eatClassControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  return (
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state)
+  )
+};
+
+pp$9.regexp_eatClassControlLetter = function(state) {
+  var ch = state.current();
+  if (isDecimalDigit(ch) || ch === 0x5F ) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatHexEscapeSequence = function(state) {
+  var start = state.pos;
+  if (state.eat(0x78 )) {
+    if (this.regexp_eatFixedHexDigits(state, 2)) {
+      return true
+    }
+    if (state.switchU) {
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+pp$9.regexp_eatDecimalDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isDecimalDigit(ch = state.current())) {
+    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 );
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isDecimalDigit(ch) {
+  return ch >= 0x30  && ch <= 0x39 
+}
+
+pp$9.regexp_eatHexDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isHexDigit(ch = state.current())) {
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isHexDigit(ch) {
+  return (
+    (ch >= 0x30  && ch <= 0x39 ) ||
+    (ch >= 0x41  && ch <= 0x46 ) ||
+    (ch >= 0x61  && ch <= 0x66 )
+  )
+}
+function hexToInt(ch) {
+  if (ch >= 0x41  && ch <= 0x46 ) {
+    return 10 + (ch - 0x41 )
+  }
+  if (ch >= 0x61  && ch <= 0x66 ) {
+    return 10 + (ch - 0x61 )
+  }
+  return ch - 0x30 
+}
+
+pp$9.regexp_eatLegacyOctalEscapeSequence = function(state) {
+  if (this.regexp_eatOctalDigit(state)) {
+    var n1 = state.lastIntValue;
+    if (this.regexp_eatOctalDigit(state)) {
+      var n2 = state.lastIntValue;
+      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
+        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
+      } else {
+        state.lastIntValue = n1 * 8 + n2;
+      }
+    } else {
+      state.lastIntValue = n1;
+    }
+    return true
+  }
+  return false
+};
+
+pp$9.regexp_eatOctalDigit = function(state) {
+  var ch = state.current();
+  if (isOctalDigit(ch)) {
+    state.lastIntValue = ch - 0x30; 
+    state.advance();
+    return true
+  }
+  state.lastIntValue = 0;
+  return false
+};
+function isOctalDigit(ch) {
+  return ch >= 0x30  && ch <= 0x37 
+}
+
+pp$9.regexp_eatFixedHexDigits = function(state, length) {
+  var start = state.pos;
+  state.lastIntValue = 0;
+  for (var i = 0; i < length; ++i) {
+    var ch = state.current();
+    if (!isHexDigit(ch)) {
+      state.pos = start;
+      return false
+    }
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return true
+};
+
+
+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]; }
+};
+
+
+var pp$8 = Parser.prototype;
+
+
+pp$8.next = function() {
+  if (this.options.onToken)
+    { this.options.onToken(new Token(this)); }
+
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
+
+pp$8.getToken = function() {
+  this.next();
+  return new Token(this)
+};
+
+if (typeof Symbol !== "undefined")
+  { pp$8[Symbol.iterator] = function() {
+    var this$1 = this;
+
+    return {
+      next: function () {
+        var token = this$1.getToken();
+        return {
+          done: token.type === types.eof,
+          value: token
+        }
+      }
+    }
+  }; }
+
+
+pp$8.curContext = function() {
+  return this.context[this.context.length - 1]
+};
+
+
+pp$8.nextToken = function() {
+  var curContext = this.curContext();
+  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+
+  this.start = this.pos;
+  if (this.options.locations) { this.startLoc = this.curPosition(); }
+  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+
+  if (curContext.override) { return curContext.override(this) }
+  else { this.readToken(this.fullCharCodeAtPos()); }
+};
+
+pp$8.readToken = function(code) {
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 )
+    { return this.readWord() }
+
+  return this.getTokenFromCode(code)
+};
+
+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
+};
+
+pp$8.skipBlockComment = function() {
+  var this$1 = this;
+
+  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()); }
+};
+
+pp$8.skipLineComment = function(startSkip) {
+  var this$1 = this;
+
+  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()); }
+};
+
+
+pp$8.skipSpace = function() {
+  var this$1 = this;
+
+  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
+      }
+    }
+  }
+};
+
+
+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.updateContext(prevType);
+};
+
+
+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) { 
+    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)
+};
+
+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 (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
+    ++size;
+    tokentype = types.starstar;
+    next = this.input.charCodeAt(this.pos + 2);
+  }
+
+  if (next === 61) { return this.finishOp(types.assign, size + 1) }
+  return this.finishOp(tokentype, size)
+};
+
+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)
+};
+
+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)
+};
+
+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)))) {
+      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)
+};
+
+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) {
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken()
+  }
+  if (next === 61) { size = 2; }
+  return this.finishOp(types.relational, size)
+};
+
+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)
+};
+
+pp$8.getTokenFromCode = function(code) {
+  switch (code) {
+  case 46: 
+    return this.readToken_dot()
+
+  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)
+
+  case 96: 
+    if (this.options.ecmaVersion < 6) { break }
+    ++this.pos;
+    return this.finishToken(types.backQuote)
+
+  case 48: 
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) { return this.readRadixNumber(16) } 
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) { return this.readRadixNumber(8) } 
+      if (next === 98 || next === 66) { 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(false)
+
+  case 34: case 39: 
+    return this.readString(code)
+
+
+  case 47: 
+    return this.readToken_slash()
+
+  case 37: case 42: 
+    return this.readToken_mult_modulo_exp(code)
+
+  case 124: case 38: 
+    return this.readToken_pipe_amp(code)
+
+  case 94: 
+    return this.readToken_caret()
+
+  case 43: case 45: 
+    return this.readToken_plus_min(code)
+
+  case 60: case 62: 
+    return this.readToken_lt_gt(code)
+
+  case 61: case 33: 
+    return this.readToken_eq_excl(code)
+
+  case 126: 
+    return this.finishOp(types.prefix, 1)
+  }
+
+  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)
+};
+
+pp$8.readRegexp = function() {
+  var this$1 = this;
+
+  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 pattern = this.input.slice(start, this.pos);
+  ++this.pos;
+  var flagsStart = this.pos;
+  var flags = this.readWord1();
+  if (this.containsEsc) { this.unexpected(flagsStart); }
+
+  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
+  state.reset(start, pattern, flags);
+  this.validateRegExpFlags(state);
+  this.validateRegExpPattern(state);
+
+  var value = null;
+  try {
+    value = new RegExp(pattern, flags);
+  } catch (e) {
+  }
+
+  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
+};
+
+
+pp$8.readInt = function(radix, len) {
+  var this$1 = this;
+
+  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; } 
+    else if (code >= 65) { val = code - 65 + 10; } 
+    else if (code >= 48 && code <= 57) { val = code - 48; } 
+    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 }
+
+  return total
+};
+
+pp$8.readRadixNumber = function(radix) {
+  this.pos += 2; 
+  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)
+};
+
+
+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) { 
+    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 str = this.input.slice(start, this.pos);
+  var val = octal ? parseInt(str, 8) : parseFloat(str);
+  return this.finishToken(types.num, val)
+};
+
+
+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
+};
+
+function codePointToString(code) {
+  if (code <= 0xFFFF) { return String.fromCharCode(code) }
+  code -= 0x10000;
+  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
+}
+
+pp$8.readString = function(quote) {
+  var this$1 = this;
+
+  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.options.ecmaVersion >= 10)) { 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 INVALID_TEMPLATE_ESCAPE_ERROR = {};
+
+pp$8.tryReadTemplateToken = function() {
+  this.inTemplateElement = true;
+  try {
+    this.readTmplToken();
+  } catch (err) {
+    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+      this.readInvalidTemplateToken();
+    } else {
+      throw err
+    }
+  }
+
+  this.inTemplateElement = false;
+};
+
+pp$8.invalidStringToken = function(position, message) {
+  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
+    throw INVALID_TEMPLATE_ESCAPE_ERROR
+  } else {
+    this.raise(position, message);
+  }
+};
+
+pp$8.readTmplToken = function() {
+  var this$1 = this;
+
+  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;
+    }
+  }
+};
+
+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
+      }
+
+    case "`":
+      return this$1.finishToken(types.invalidTemplate, this$1.input.slice(this$1.start, this$1.pos))
+
+    }
+  }
+  this.raise(this.start, "Unterminated template");
+};
+
+
+pp$8.readEscapedChar = function(inTemplate) {
+  var ch = this.input.charCodeAt(++this.pos);
+  ++this.pos;
+  switch (ch) {
+  case 110: return "\n" 
+  case 114: return "\r" 
+  case 120: return String.fromCharCode(this.readHexChar(2)) 
+  case 117: return codePointToString(this.readCodePoint()) 
+  case 116: return "\t" 
+  case 98: return "\b" 
+  case 118: return "\u000b" 
+  case 102: return "\f" 
+  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } 
+  case 10: 
+    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);
+      }
+      this.pos += octalStr.length - 1;
+      ch = this.input.charCodeAt(this.pos);
+      if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
+        this.invalidStringToken(
+          this.pos - 1 - octalStr.length,
+          inTemplate
+            ? "Octal literal in template string"
+            : "Octal literal in strict mode"
+        );
+      }
+      return String.fromCharCode(octal)
+    }
+    return String.fromCharCode(ch)
+  }
+};
+
+
+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
+};
+
+
+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) 
+        { 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)
+};
+
+
+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)
+};
+
+
+var version = "5.7.1";
+
+
+function parse(input, options) {
+  return new Parser(options, input).parse()
+}
+
+
+function parseExpressionAt(input, pos, options) {
+  var p = new Parser(options, input, pos);
+  p.nextToken();
+  return p.parseExpression()
+}
+
+
+function tokenizer(input, options) {
+  return new Parser(options, input)
+}
+
+function addLooseExports(parse, Parser$$1, plugins$$1) {
+  exports.parse_dammit = parse; 
+  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 });
+
+})));
+
+},{}]},{},[33]);
diff --git a/bin/gpu.min.js b/bin/gpu.min.js
new file mode 100644
index 00000000..00b3cf1c
--- /dev/null
+++ b/bin/gpu.min.js
@@ -0,0 +1,22 @@
+/**
+ * gpu.js
+ * http://gpu.rocks/
+ *
+ * GPU Accelerated JavaScript
+ *
+ * @version 1.10.4
+ * @date Sun Feb 10 2019 20:40:25 GMT-0600 (Central Standard Time)
+ *
+ * @license MIT
+ * The MIT License
+ *
+ * Copyright (c) 2019 gpu.js Team
+ */
+"use strict";!function(){function t(e,n,r){function i(a,o){if(!n[a]){if(!e[a]){var u="function"==typeof require&&require;if(!o&&u)return u(a,!0);if(s)return s(a,!0);var h=new Error("Cannot find module '"+a+"'");throw h.code="MODULE_NOT_FOUND",h}var c=n[a]={exports:{}};e[a][0].call(c.exports,function(t){var n=e[a][1][t];return i(n||t)},c,c.exports,t,e,n,r)}return n[a].exports}for(var s="function"==typeof require&&require,a=0;a<r.length;a++)i(r[a]);return i}return t}()({1:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=t("../function-builder-base"),o=t("./function-node");e.exports=function(t){function e(){r(this,e);var t=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this));return t.Node=o,t}return s(e,t),e}(a)},{"../function-builder-base":6,"./function-node":2}],2:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("../function-node-base"),u=t("../../core/utils");e.exports=function(t){function e(t,n,s){r(this,e);var a=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t,n,s));return a.paramSizes=s?s.paramSizes:[],a.memberStates=[],a}return s(e,t),a(e,[{key:"pushMemberState",value:function(t){this.memberStates.push(t)}},{key:"popMemberState",value:function(t){if(this.memberState!==t)throw new Error("Cannot popMemberState "+t+" when in "+this.memberState);this.memberStates.pop()}},{key:"generate",value:function(){return this.debug&&console.log(this),this.functionStringArray=this.astGeneric(this.getJsAST(),[]),this.functionString=this.functionStringArray.join("").trim(),this.functionString}},{key:"getFunctionPrototypeString",value:function(){return this.webGlFunctionPrototypeString?this.webGlFunctionPrototypeString:this.webGlFunctionPrototypeString=this.generate()}},{key:"astFunctionDeclaration",value:function(t,e){return this.builder.addFunction(null,u.getAstString(this.jsFunctionString,t)),e}},{key:"astFunctionPrototype",value:function(t,e){if(this.isRootKernel||this.isSubKernel)return e;e.push(this.returnType),e.push(" "),e.push(this.functionName),e.push("(");for(var n=0;n<this.paramNames.length;++n)n>0&&e.push(", "),e.push("user_"),e.push(this.paramNames[n]);return e.push(");\n"),e}},{key:"astFunctionExpression",value:function(t,e){if(!this.isRootKernel){e.push("function"),e.push(" "),e.push(this.functionName),e.push("(");for(var n=0;n<this.paramNames.length;++n){var r=this.paramNames[n];n>0&&e.push(", "),e.push("user_"),e.push(r)}e.push(") {\n")}for(var i=0;i<t.body.body.length;++i)this.astGeneric(t.body.body[i],e),e.push("\n");return this.isRootKernel||e.push("}\n"),e}},{key:"astReturnStatement",value:function(t,e){return this.isRootKernel?(e.push("kernelResult = "),this.astGeneric(t.argument,e),e.push(";")):this.isSubKernel?(e.push(this.functionName+"Result = "),this.astGeneric(t.argument,e),e.push(";"),e.push("return "+this.functionName+"Result;")):(e.push("return "),this.astGeneric(t.argument,e),e.push(";")),e}},{key:"astLiteral",value:function(t,e){if(isNaN(t.value))throw this.astErrorOutput("Non-numeric literal not supported : "+t.value,t);return e.push(t.value),e}},{key:"astBinaryExpression",value:function(t,e){return e.push("("),this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e),e.push(")"),e}},{key:"astIdentifierExpression",value:function(t,e){if("Identifier"!==t.type)throw this.astErrorOutput("IdentifierExpression - not an Identifier",t);switch(this.state){case"input-index-y":case"input-index-z":e.push("(")}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;case"Infinity":e.push("Infinity");break;default:if(this.constants&&this.constants.hasOwnProperty(t.name))e.push("constants_"+t.name);else{var n=this.getUserParamName(t.name);null!==n?e.push("user_"+n):e.push("user_"+t.name)}}switch(this.state){case"input-index-y":var r=this.paramSizes[this.paramNames.indexOf(this.memberState)];e.push(" * "+r[0]+")");break;case"input-index-z":var i=this.paramSizes[this.paramNames.indexOf(this.memberState)];e.push(" * "+i[0]*i[1]+")")}return e}},{key:"astForStatement",value:function(t,e){if("ForStatement"!==t.type)throw this.astErrorOutput("Invalid for statement",t);if(t.test&&"BinaryExpression"===t.test.type){if(("Identifier"===t.test.right.type||"Literal"===t.test.right.type)&&"<"===t.test.operator&&this.isIdentifierConstant(t.test.right.name)===!1){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),";"!==e[e.length-1]&&e.push(";"),this.astGeneric(t.test.left,e),e.push(t.test.operator),e.push("LOOP_MAX"),e.push(";"),this.astGeneric(t.update,e),e.push(")"),e.push("{\n"),e.push("if ("),this.astGeneric(t.test.left,e),e.push(t.test.operator),this.astGeneric(t.test.right,e),e.push(") {\n"),"BlockStatement"===t.body.type)for(var n=0;n<t.body.body.length;n++)this.astGeneric(t.body.body[n],e);else this.astGeneric(t.body,e);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)),i=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 s=null,a=0;a<r.length;a++){var o=r[a];o.id.name===i.name?(s=o,r.splice(a,1)):(e.push("var "),this.astGeneric(o,e),e.push(";"))}e.push("for (let "),this.astGeneric(s,e),e.push(";")}else e.push("for ("),this.astGeneric(t.init,e);return this.astGeneric(t.test,e),e.push(";"),this.astGeneric(t.update,e),e.push(")"),this.astGeneric(t.body,e),e}}throw this.astErrorOutput("Invalid for statement",t)}},{key:"astWhileStatement",value:function(t,e){if("WhileStatement"!==t.type)throw this.astErrorOutput("Invalid while statement",t);return e.push("for (let i = 0; i < LOOP_MAX; i++) {"),e.push("if ("),this.astGeneric(t.test,e),e.push(") {\n"),this.astGeneric(t.body,e),e.push("} else {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}},{key:"astDoWhileStatement",value:function(t,e){if("DoWhileStatement"!==t.type)throw this.astErrorOutput("Invalid while statement",t);return e.push("for (let i = 0; i < LOOP_MAX; i++) {"),this.astGeneric(t.body,e),e.push("if (!"),this.astGeneric(t.test,e),e.push(") {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}},{key:"astAssignmentExpression",value:function(t,e){return this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e),e}},{key:"astEmptyStatement",value:function(t,e){return e}},{key:"astBlockStatement",value:function(t,e){e.push("{\n");for(var n=0;n<t.body.length;n++)this.astGeneric(t.body[n],e);return e.push("}\n"),e}},{key:"astExpressionStatement",value:function(t,e){return this.astGeneric(t.expression,e),e.push(";"),e}},{key:"astVariableDeclaration",value:function(t,e){e.push("var ");for(var n=0;n<t.declarations.length;n++)this.declarations[t.declarations[n].id.name]="var",n>0&&e.push(","),this.astGeneric(t.declarations[n],e);return e.push(";"),e}},{key:"astVariableDeclarator",value:function(t,e){return this.astGeneric(t.id,e),null!==t.init&&(e.push("="),this.astGeneric(t.init,e)),e}},{key:"astIfStatement",value:function(t,e){return e.push("if ("),this.astGeneric(t.test,e),e.push(")"),"BlockStatement"===t.consequent.type?this.astGeneric(t.consequent,e):(e.push(" {\n"),this.astGeneric(t.consequent,e),e.push("\n}\n")),t.alternate&&(e.push("else "),"BlockStatement"===t.alternate.type?this.astGeneric(t.alternate,e):(e.push(" {\n"),this.astGeneric(t.alternate,e),e.push("\n}\n"))),e}},{key:"astBreakStatement",value:function(t,e){return e.push("break;\n"),e}},{key:"astContinueStatement",value:function(t,e){return e.push("continue;\n"),e}},{key:"astLogicalExpression",value:function(t,e){return e.push("("),this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e),e.push(")"),e}},{key:"astUpdateExpression",value:function(t,e){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e)):(this.astGeneric(t.argument,e),e.push(t.operator)),e}},{key:"astUnaryExpression",value:function(t,e){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e)):(this.astGeneric(t.argument,e),e.push(t.operator)),e}},{key:"astThisExpression",value:function(t,e){return e.push("_this"),e}},{key:"astMemberExpression",value:function(t,e){if(t.computed)if("Identifier"===t.object.type||"MemberExpression"===t.object.type&&t.object.object.object&&"ThisExpression"===t.object.object.object.type&&"constants"===t.object.object.property.name)this.pushState("identifier"),this.astGeneric(t.object,e),this.popState("identifier"),e.push("["),this.isInput(t.object.name)?this.astGeneric(t.property,e):this.astGeneric(t.property,e),e.push("]");else if(t.object.object)if(t.object.object.object&&this.isInput(t.object.object.object.name)){this.pushMemberState(t.object.object.object.name),this.pushState("input-index-z"),this.astGeneric(t.object,e);var n=e.pop();e.push(" + "),this.popState("input-index-z"),this.pushState("input-index"),this.astGeneric(t.property,e),this.popState("input-index"),e.push(n),this.popMemberState(t.object.object.object.name)}else if(this.isInput(t.object.object.name)){this.pushMemberState(t.object.object.name),this.isState("input-index-z")||this.pushState("input-index-y"),this.astGeneric(t.object,e);var r=e.pop();e.push(" + "),this.isState("input-index-z")||this.popState("input-index-y");var i=this.isState("input-index-z");i?this.pushState("input-index-y"):this.pushState("input-index"),this.astGeneric(t.property,e),i?this.popState("input-index-y"):this.popState("input-index"),e.push(r),this.popMemberState(t.object.object.name)}else{this.astGeneric(t.object,e);var s=e.pop();e.push("]["),this.astGeneric(t.property,e),e.push(s)}else{this.astGeneric(t.object,e);var a=e.pop();e.push("]["),this.astGeneric(t.property,e),e.push(a)}else{var o=this.astMemberExpressionUnroll(t);switch("Identifier"===t.property.type&&t.computed&&(o="user_"+o),0===o.indexOf("this.constants")?o="constants_"+o.substring(15):0===o.indexOf("this")&&(o="_"+o),this.state){case"input-index-y":case"input-index-z":e.push("(")}switch(o){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:t.object&&t.object.name&&this.declarations[t.object.name]&&e.push("user_"),e.push(o)}switch(this.state){case"input-index-y":var u=this.paramSizes[this.paramNames.indexOf(this.memberState)];e.push(" * "+u[0]+")");break;case"input-index-z":var h=this.paramSizes[this.paramNames.indexOf(this.memberState)];e.push(" * "+h[0]*h[1]+")")}}return e}},{key:"astSequenceExpression",value:function(t,e){for(var n=0;n<t.expressions.length;n++)n>0&&e.push(","),this.astGeneric(t.expressions,e);return e}},{key:"astCallExpression",value:function(t,e){if(t.callee){var n=this.astMemberExpressionUnroll(t.callee);this.calledFunctions.indexOf(n)<0&&this.calledFunctions.push(n),this.hasOwnProperty("funcName")||(this.calledFunctionsArguments[n]=[]);var r=[];this.calledFunctionsArguments[n].push(r),e.push(n),e.push("(");for(var i=0;i<t.arguments.length;++i){var s=t.arguments[i];if(i>0&&e.push(", "),this.astGeneric(s,e),"Identifier"===s.type){var a=this.paramNames.indexOf(s.name);a===-1?r.push(null):r.push({name:s.name,type:this.paramTypes[a]})}else r.push(null)}return e.push(")"),e}throw this.astErrorOutput("Unknown CallExpression",t)}},{key:"astArrayExpression",value:function(t,e){var n=t.elements.length;e.push("[");for(var r=0;r<n;++r){r>0&&e.push(", ");var i=t.elements[r];this.astGeneric(i,e)}return e.push("]"),e}},{key:"astDebuggerStatement",value:function(t,e){return e.push("debugger;"),e}},{key:"memberState",get:function(){return this.memberStates[this.memberStates.length-1]}}]),e}(o)},{"../../core/utils":32,"../function-node-base":7}],3:[function(t,e,n){function r(t){return/^function /.test(t)&&(t=t.substring(9)),t.replace(/[_]typeof/g,"typeof")}function i(t){return t.replace(/[_]typeof/g,"typeof")}var s=t("../../core/utils"),a=t("../kernel-run-shortcut");e.exports=function(t,e){return"() => {\n    "+a.toString()+";\n    const utils = {\n      allPropertiesOf: "+i(s.allPropertiesOf.toString())+",\n      clone: "+i(s.clone.toString())+",\n      checkOutput: "+i(s.checkOutput.toString())+"\n    };\n    const Utils = utils;\n    let Input = function() {};\n    class "+(e||"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._kernelString = `"+t._kernelString+"`;\n        this.output = "+JSON.stringify(t.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      setInput(Type) { Input = Type; }\n      "+r(t.build.toString())+"\n      "+r(t.setupParams.toString())+"\n      "+r(t.setupConstants.toString())+"\n      run () { "+t.kernelString+" }\n      getKernelString() { return this._kernelString; }\n      "+r(t.validateOptions.toString())+"\n    };\n    return kernelRunShortcut(new Kernel());\n  };"}},{"../../core/utils":32,"../kernel-run-shortcut":9}],4:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("../kernel-base"),u=t("../../core/utils"),h=t("./kernel-string");e.exports=function(t){function e(t,n){r(this,e);var s=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t,n));return s._fn=null,s.run=null,s._canvasCtx=null,s._imageData=null,s._colorData=null,s._kernelString=null,s.thread={x:0,y:0,z:0},s.run=function(){return this.run=null,this.build.apply(this,arguments),this.run.apply(this,arguments)}.bind(s),s}return s(e,t),a(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=u.getArgumentType(arguments[0]);if("Array"===t)this.output=u.getDimensions(t);else{if("NumberTexture"!==t&&"ArrayTexture(4)"!==t)throw"Auto dimensions not supported for input type: "+t;this.output=arguments[0].output}}u.checkOutput(this.output)}},{key:"build",value:function(){this.setupConstants(),this.setupParams(arguments),this.validateOptions();var t=this._canvas;t&&(this._canvasCtx=t.getContext("2d"));for(var e=this.threadDim=u.clone(this.output);e.length<3;)e.push(1);if(this.graphical){var n=this._canvas;if(!n)throw new Error("no canvas available for using graphical output");n.width=e[0],n.height=e[1],this._imageData=this._canvasCtx.createImageData(e[0],e[1]),this._colorData=new Uint8ClampedArray(e[0]*e[1]*4)}var r=this.getKernelString();this.debug&&(console.log("Options:"),console.dir(this),console.log("Function output:"),console.log(r)),this.kernelString=r,this.run=new Function([],r).bind(this)()}},{key:"color",value:function(t,e,n,r){"undefined"==typeof 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],a=this.thread.x,o=s-this.thread.y-1,u=a+o*i;this._colorData[4*u+0]=t,this._colorData[4*u+1]=e,this._colorData[4*u+2]=n,this._colorData[4*u+3]=r}},{key:"getKernelString",value:function(){if(null!==this._kernelString)return this._kernelString;for(var t=this.functionBuilder,e=this.threadDim||(this.threadDim=u.clone(this.output));e.length<3;)e.push(1);if(t.addKernel(this.fnString,{prototypeOnly:!1,constants:this.constants,output:e,debug:this.debug,loopMaxIterations:this.loopMaxIterations,paramNames:this.paramNames,paramTypes:this.paramTypes,paramSizes:this.paramSizes,constantTypes:this.constantTypes}),t.addFunctions(this.functions,{constants:this.constants,output:e}),t.addNativeFunctions(this.nativeFunctions),null!==this.subKernels){this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[];for(var n=0;n<this.subKernels.length;n++){var r=this.subKernels[n];t.addSubKernel(r,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations}),this.subKernelOutputVariableNames.push(r.name+"Result")}}else if(null!==this.subKernelProperties){this.subKernelOutputVariableNames=[];var i=0;for(var s in this.subKernelProperties)if(this.subKernelProperties.hasOwnProperty(s)){var a=this.subKernelProperties[s];t.addSubKernel(a),this.subKernelOutputVariableNames.push(a.name+"Result"),i++}}var o=t.getPrototypes("kernel"),h=null;o.length>1?o=o.filter(function(t){return/^function/.test(t)?t:(h=t,!1)}):h=o.shift();var c=this._kernelString="\n\t\tvar LOOP_MAX = "+this._getLoopMaxString()+"\n\t\tvar constants = this.constants;\n\t\tvar _this = this;\n    return function ("+this.paramNames.map(function(t){return"user_"+t}).join(", ")+") {\n      "+this._processConstants()+"\n      "+this._processParams()+"\n      "+this._kernelLoop(h)+"\n      if (this.graphical) {\n        this._imageData.data.set(this._colorData);\n        this._canvasCtx.putImageData(this._imageData, 0, 0);\n        return;\n      }\n      "+this._kernelOutput()+"\n      "+(o.length>0?o.join("\n"):"")+"\n    }.bind(this);";return c}},{key:"toString",value:function(){return h(this)}},{key:"_getLoopMaxString",value:function(){return this.loopMaxIterations?" "+parseInt(this.loopMaxIterations)+";\n":" 1000;\n"}},{key:"_processConstants",value:function(){if(!this.constants)return"";var t=[];for(var e in this.constants){var n=this.constantTypes[e];switch(n){case"HTMLImage":t.push("  var constants_"+e+" = this._imageTo2DArray(this.constants."+e+")");break;case"HTMLImageArray":t.push("  var constants_"+e+" = this._imageTo3DArray(this.constants."+e+")");break;case"Input":t.push("  var constants_"+e+" = this.constants."+e+".value");break;default:t.push("  var constants_"+e+" = this.constants."+e)}}return t.join("\n")}},{key:"_processParams",value:function(){for(var t=[],e=0;e<this.paramTypes.length;e++)switch(this.paramTypes[e]){case"HTMLImage":t.push("  user_"+this.paramNames[e]+" = this._imageTo2DArray(user_"+this.paramNames[e]+")");break;case"HTMLImageArray":t.push("  user_"+this.paramNames[e]+" = this._imageTo3DArray(user_"+this.paramNames[e]+")");break;case"Input":t.push("  user_"+this.paramNames[e]+" = user_"+this.paramNames[e]+".value")}return t.join(";\n")}},{key:"_imageTo2DArray",value:function(t){var e=this._canvas;e.width<t.width&&(e.width=t.width),e.height<t.height&&(e.height=t.height);var n=this._canvasCtx;n.drawImage(t,0,0,t.width,t.height);for(var r=n.getImageData(0,0,t.width,t.height).data,i=new Array(t.height),s=0,a=t.height-1;a>=0;a--){i[a]=new Array(t.width);for(var o=0;o<t.width;o++){var u=r[s++]/255,h=r[s++]/255,c=r[s++]/255,l=r[s++]/255,p=[u,h,c,l];p.r=u,p.g=h,p.b=c,p.a=l,i[a][o]=p}}return i}},{key:"_imageTo3DArray",value:function(t){for(var e=new Array(t.length),n=0;n<t.length;n++)e[n]=this._imageTo2DArray(t[n]);return e}},{key:"_kernelLoop",value:function(t){switch(this.output.length){case 1:return this._kernel1DLoop(t);case 2:return this._kernel2DLoop(t);case 3:return this._kernel3DLoop(t);default:throw new Error("unsupported size kernel")}}},{key:"_kernel1DLoop",value:function(t){var e=this.threadDim;return"\n    var result = new Float32Array("+e[0]+");\n    "+this._mapSubKernels(function(t){return"var result_"+t+" = new Float32Array("+e[0]+");\n"}).join("")+"\n    for (var x = 0; x < "+e[0]+"; x++) {\n      this.thread.x = x;\n      this.thread.y = 0;\n      this.thread.z = 0;\n      var kernelResult;\n      "+t+"\n      result[x] = kernelResult;\n      "+this._mapSubKernels(function(t){return"result_"+t+"[x] = "+t+";\n"}).join("")+"\n    }"}},{key:"_kernel2DLoop",value:function(t){var e=this.threadDim;return"\n    var result = new Array("+e[1]+");\n    "+this._mapSubKernels(function(t){return"var result_"+t+" = new Array("+e[1]+");\n"}).join("")+"\n    for (var y = 0; y < "+e[1]+"; y++) {\n      this.thread.z = 0;\n      this.thread.y = y;\n      var resultX = result[y] = new Float32Array("+e[0]+");\n      "+this._mapSubKernels(function(t){return"var result_"+t+"X = result_"+t+"[y] = new Float32Array("+e[0]+");\n"}).join("")+"\n      for (var x = 0; x < "+e[0]+"; x++) {\n      \tthis.thread.x = x;\n        var kernelResult;\n        "+t+"\n        resultX[x] = kernelResult;\n        "+this._mapSubKernels(function(t){return"result_"+t+"X[x] = "+t+";\n"}).join("")+"\n      }\n    }"}},{key:"_kernel3DLoop",value:function(t){var e=this.threadDim;return"\n    var result = new Array("+e[2]+");\n    "+this._mapSubKernels(function(t){return"var result_"+t+" = new Array("+e[2]+");\n"}).join("")+"\n    for (var z = 0; z < "+e[2]+"; z++) {\n      this.thread.z = z;\n      var resultY = result[z] = new Array("+e[1]+");\n      "+this._mapSubKernels(function(t){return"var result_"+t+"Y = result_"+t+"[z] = new Array("+e[1]+");\n"}).join("")+"\n      for (var y = 0; y < "+e[1]+"; y++) {\n        this.thread.y = y;\n        var resultX = resultY[y] = new Float32Array("+e[0]+");\n        "+this._mapSubKernels(function(t){return"var result_"+t+"X = result_"+t+"Y[y] = new Float32Array("+e[0]+");\n"}).join("")+"\n        for (var x = 0; x < "+e[0]+"; x++) {\n        \tthis.thread.x = x;\n          var kernelResult;\n          "+t+"\n          resultX[x] = kernelResult;\n          "+this._mapSubKernels(function(t){return"result_"+t+"X[x] = "+t+";\n"}).join("")+"\n        }\n      }\n    }"}},{key:"_kernelOutput",value:function(){var t=this;return this.subKernelOutputVariableNames?"return {\n      result: result,\n      "+Object.keys(this.subKernelProperties||this.subKernelOutputVariableNames).map(function(e,n){return e+": result_"+t.subKernelOutputVariableNames[n]}).join(",\n")+"\n    };":"return result;"}},{key:"_mapSubKernels",value:function(t){return null===this.subKernelOutputVariableNames?[""]:this.subKernelOutputVariableNames.map(t)}}]),e}(o)},{"../../core/utils":32,"../kernel-base":8,"./kernel-string":3}],5:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=(t("../../core/utils"),t("../runner-base")),u=t("./kernel"),h=t("./function-builder");e.exports=function(t){function e(t){r(this,e);var n=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,new h,t));return n.Kernel=u,n.kernel=null,n}return s(e,t),a(e,[{key:"getMode",value:function(){return"cpu"}}]),e}(o)},{"../../core/utils":32,"../runner-base":10,"./function-builder":1,"./kernel":4}],6:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}();e.exports=function(){function t(e){r(this,t),this.nodeMap={},this.nativeFunctions={},this.gpu=e,this.rootKernel=null,this.Node=null}return i(t,[{key:"addNativeFunction",value:function(t,e){this.nativeFunctions[t]=e}},{key:"addFunction",value:function(t,e,n){this.addFunctionNode(new this.Node(t,e,n).setBuilder(this))}},{key:"addFunctions",value:function(t,e){if(t)if(Array.isArray(t))for(var n=0;n<t.length;n++)this.addFunction(null,t[n],e);else for(var r in t)this.addFunction(r,t[r],e)}},{key:"addNativeFunctions",value:function(t){for(var e in t)t.hasOwnProperty(e)&&this.addNativeFunction(e,t[e])}},{key:"addFunctionNode",value:function(t){this.nodeMap[t.functionName]=t,t.isRootKernel&&(this.rootKernel=t)}},{key:"traceFunctionCalls",value:function(t,e,n){t=t||"kernel",e=e||[];var r=this.nodeMap[t];if(r){var i=e.indexOf(t);if(i===-1){e.push(t),n&&(r.parent=n),r.getFunctionString();for(var s=0;s<r.calledFunctions.length;++s)this.traceFunctionCalls(r.calledFunctions[s],e,r)}else{var a=e.splice(i,1)[0];e.push(a)}}return this.nativeFunctions[t]&&(e.indexOf(t)>=0||e.push(t)),e}},{key:"addKernel",value:function(t,e){var n=new this.Node("kernel",t,e);return n.setBuilder(this),n.isRootKernel=!0,this.addFunctionNode(n),n}},{key:"addSubKernel",value:function(t,e){var n=new this.Node(null,t,e);return n.setBuilder(this),n.isSubKernel=!0,this.addFunctionNode(n),n}},{key:"getPrototypeString",value:function(t){return this.getPrototypes(t).join("\n")}},{key:"getPrototypes",value:function(t){return this.rootKernel.generate(),t?this.getPrototypesFromFunctionNames(this.traceFunctionCalls(t,[]).reverse()):this.getPrototypesFromFunctionNames(Object.keys(this.nodeMap))}},{key:"getStringFromFunctionNames",value:function(t){for(var e=[],n=0;n<t.length;++n){var r=this.nodeMap[t[n]];r&&e.push(this.nodeMap[t[n]].getFunctionString())}return e.join("\n")}},{key:"getPrototypesFromFunctionNames",value:function(t,e){for(var n=[],r=0;r<t.length;++r){var i=t[r],s=this.nodeMap[i];s?n.push(s.getFunctionPrototypeString(e)):this.nativeFunctions[i]&&n.push(this.nativeFunctions[i])}return n}},{key:"getPrototypeStringFromFunctionNames",value:function(t,e){return this.getPrototypesFromFunctionNames(t,e).toString()}},{key:"getString",value:function(t,e){return void 0===e&&(e={}),t?this.getStringFromFunctionNames(this.traceFunctionCalls(t,[],e).reverse(),e):this.getStringFromFunctionNames(Object.keys(this.nodeMap),e)}}]),t}()},{}],7:[function(require,module,exports){function _classCallCheck(t,e){if(!(t instanceof e))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,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}}(),utils=require("../core/utils"),acorn=require("acorn");module.exports=function(){function BaseFunctionNode(t,e,n){_classCallCheck(this,BaseFunctionNode),this.calledFunctions=[],this.calledFunctionsArguments={},this.builder=null,this.isRootKernel=!1,this.isSubKernel=!1,this.parent=null,this.debug=null,this.prototypeOnly=null,this.constants=null,this.output=null,this.declarations={},this.states=[],this.fixIntegerDivisionAccuracy=null;var r=void 0,i=void 0;if(n&&(n.hasOwnProperty("debug")&&(this.debug=n.debug),n.hasOwnProperty("prototypeOnly")&&(this.prototypeOnly=n.prototypeOnly),n.hasOwnProperty("constants")&&(this.constants=n.constants),n.hasOwnProperty("output")&&(this.output=n.output),n.hasOwnProperty("loopMaxIterations")&&(this.loopMaxIterations=n.loopMaxIterations),n.hasOwnProperty("paramTypes")&&(this.paramTypes=r=n.paramTypes),n.hasOwnProperty("constantTypes")?this.constantTypes=n.constantTypes:this.constantTypes={},n.hasOwnProperty("returnType")&&(i=n.returnType),n.hasOwnProperty("fixIntegerDivisionAccuracy")&&(this.fixIntegerDivisionAccuracy=n.fixIntegerDivisionAccuracy)),!e)throw"jsFunction, parameter is missing";if(this.jsFunctionString=e.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(e)?this.jsFunction=e:this.jsFunction=null,this.functionName=t||e&&e.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"===("undefined"==typeof 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]:"Number"})}}else this.paramTypes=[];this.returnType||(this.returnType=i||"Number")}return _createClass(BaseFunctionNode,[{key:"isIdentifierConstant",value:function(t){return!!this.constants&&this.constants.hasOwnProperty(t)}},{key:"isInput",value:function(t){return"Input"===this.paramTypes[this.paramNames.indexOf(t)]}},{key:"setBuilder",value:function(t){return this.builder=t,this;
+}},{key:"pushState",value:function(t){this.states.push(t)}},{key:"popState",value:function(t){if(this.state!==t)throw new Error("Cannot popState "+t+" when in "+this.state);this.states.pop()}},{key:"isState",value:function(t){return this.state===t}},{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){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):this.astMemberExpressionUnroll(t.object)+"."+this.astMemberExpressionUnroll(t.property);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)}},{key:"getJsAST",value:function(t){if(this.jsFunctionAST)return this.jsFunctionAST;if(t=t||acorn,null===t)throw"Missing JS to AST parser";var e=t.parse("var "+this.functionName+" = "+this.jsFunctionString+";",{locations:!0});if(null===e)throw"Failed to parse JS code";var n=e.body[0].declarations[0].init;return this.jsFunctionAST=n,n}},{key:"getFunctionString",value:function(){return this.generate(),this.functionString}},{key:"setFunctionString",value:function(t){this.functionString=t}},{key:"getParamType",value:function(t){var e=this.paramNames.indexOf(t);if(e===-1)return this.declarations.hasOwnProperty(t)?this.declarations[t]:"Number";if(this.parent){if(this.paramTypes[e])return this.paramTypes[e];for(var n=this.parent.calledFunctionsArguments[this.functionName],r=0;r<n.length;r++){var i=n[r];if(null!==i[e])return this.paramTypes[e]=i[e].type}}else if(this.paramTypes[e])return this.paramTypes[e];return"Number"}},{key:"getConstantType",value:function(t){return this.constantTypes[t]?this.constantTypes[t]:null}},{key:"getUserParamName",value:function(t){var e=this.paramNames.indexOf(t);if(e===-1)return null;if(!this.parent||!this.isSubKernel)return null;for(var n=this.parent.calledFunctionsArguments[this.functionName],r=0;r<n.length;r++){var i=n[r],s=i[e];if(null!==s&&"Integer"!==s.type)return s.name}return null}},{key:"generate",value:function(t){throw new Error("generate not defined on BaseFunctionNode")}},{key:"astGeneric",value:function(t,e){if(null===t)throw this.astErrorOutput("NULL ast",t);if(Array.isArray(t)){for(var n=0;n<t.length;n++)this.astGeneric(t[n],e);return e}switch(t.type){case"FunctionDeclaration":return this.astFunctionDeclaration(t,e);case"FunctionExpression":return this.astFunctionExpression(t,e);case"ReturnStatement":return this.astReturnStatement(t,e);case"Literal":return this.astLiteral(t,e);case"BinaryExpression":return this.astBinaryExpression(t,e);case"Identifier":return this.astIdentifierExpression(t,e);case"AssignmentExpression":return this.astAssignmentExpression(t,e);case"ExpressionStatement":return this.astExpressionStatement(t,e);case"EmptyStatement":return this.astEmptyStatement(t,e);case"BlockStatement":return this.astBlockStatement(t,e);case"IfStatement":return this.astIfStatement(t,e);case"BreakStatement":return this.astBreakStatement(t,e);case"ContinueStatement":return this.astContinueStatement(t,e);case"ForStatement":return this.astForStatement(t,e);case"WhileStatement":return this.astWhileStatement(t,e);case"DoWhileStatement":return this.astDoWhileStatement(t,e);case"VariableDeclaration":return this.astVariableDeclaration(t,e);case"VariableDeclarator":return this.astVariableDeclarator(t,e);case"ThisExpression":return this.astThisExpression(t,e);case"SequenceExpression":return this.astSequenceExpression(t,e);case"UnaryExpression":return this.astUnaryExpression(t,e);case"UpdateExpression":return this.astUpdateExpression(t,e);case"LogicalExpression":return this.astLogicalExpression(t,e);case"MemberExpression":return this.astMemberExpression(t,e);case"CallExpression":return this.astCallExpression(t,e);case"ArrayExpression":return this.astArrayExpression(t,e);case"DebuggerStatement":return this.astDebuggerStatement(t,e)}throw this.astErrorOutput("Unknown ast type : "+t.type,t)}},{key:"astErrorOutput",value:function(t,e){return console.error(utils.getAstString(this.jsFunctionString,e)),console.error(t,e,this),t}},{key:"astDebuggerStatement",value:function(t,e){return e}},{key:"astFunctionDeclaration",value:function(t,e){return e}},{key:"astFunctionExpression",value:function(t,e){return e}},{key:"astReturnStatement",value:function(t,e){return e}},{key:"astLiteral",value:function(t,e){return e}},{key:"astBinaryExpression",value:function(t,e){return e}},{key:"astIdentifierExpression",value:function(t,e){return e}},{key:"astAssignmentExpression",value:function(t,e){return e}},{key:"astExpressionStatement",value:function(t,e){return e}},{key:"astEmptyStatement",value:function(t,e){return e}},{key:"astBlockStatement",value:function(t,e){return e}},{key:"astIfStatement",value:function(t,e){return e}},{key:"astBreakStatement",value:function(t,e){return e}},{key:"astContinueStatement",value:function(t,e){return e}},{key:"astForStatement",value:function(t,e){return e}},{key:"astWhileStatement",value:function(t,e){return e}},{key:"astDoWhileStatement",value:function(t,e){return e}},{key:"astVariableDeclaration",value:function(t,e){return e}},{key:"astVariableDeclarator",value:function(t,e){return e}},{key:"astThisExpression",value:function(t,e){return e}},{key:"astSequenceExpression",value:function(t,e){return e}},{key:"astUnaryExpression",value:function(t,e){return e}},{key:"astUpdateExpression",value:function(t,e){return e}},{key:"astLogicalExpression",value:function(t,e){return e}},{key:"astMemberExpression",value:function(t,e){return e}},{key:"astCallExpression",value:function(t,e){return e}},{key:"astArrayExpression",value:function(t,e){return e}},{key:"pushParameter",value:function(t,e){this.isState("in-get-call-parameters")?t.push("int("+e+")"):t.push(e)}},{key:"state",get:function(){return this.states[this.states.length-1]}}]),BaseFunctionNode}()},{"../core/utils":32,acorn:34}],8:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}(),s=t("../core/utils"),a=t("../core/input");e.exports=function(){function t(e,n){r(this,t),this.paramNames=s.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.outputImmutable=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.subKernels=null,this.subKernelProperties=null,this.subKernelNames=null,this.subKernelOutputVariableNames=null,this.functionBuilder=null,this.paramTypes=null,this.paramSizes=null,this.constantTypes=null,this.fixIntegerDivisionAccuracy=null,this.constrainStart=null,this.constrainEnd=null;for(var i in n)n.hasOwnProperty(i)&&this.hasOwnProperty(i)&&(this[i]=n[i]);n.hasOwnProperty("canvas")&&(this._canvas=n.canvas),n.hasOwnProperty("webGl")&&(this._webGl=n.webGl),n.hasOwnProperty("output")&&this.setOutput(n.output),this._canvas||(this._canvas=s.initCanvas())}return i(t,[{key:"build",value:function(){throw new Error('"build" not defined on Base')}},{key:"setupParams",value:function(t){this.paramTypes=[],this.paramSizes=[];for(var e=0;e<t.length;e++){var n=t[e];this.paramTypes.push(s.getArgumentType(n)),this.paramSizes.push(n.constructor===a?n.size:null)}}},{key:"setupConstants",value:function(){if(this.constantTypes={},this.constants)for(var t in this.constants)this.constantTypes[t]=s.getArgumentType(this.constants[t])}},{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:"constrain",value:function(t,e){return this.constrainStart=t||null,this.constrainEnd=e||null,this}},{key:"deconstrain",value:function(){return this.constrainStart=null,this.constrainEnd=null,this}},{key:"setLoopMaxIterations",value:function(t){return this.loopMaxIterations=t,this}},{key:"setFixIntegerDivisionAccuracy",value:function(t){return this.fixIntegerDivisionAccuracy=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:"setOutputImmutable",value:function(t){return this.outputImmutable=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:"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 s.newPromise(function(n,r){try{n(t.run.apply(t,e))}catch(i){r(i)}})}},{key:"addSubKernel",value:function(t){return null===this.subKernels&&(this.subKernels=[],this.subKernelNames=[]),this.subKernels.push(t),this.subKernelNames.push(s.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(s.getFunctionNameFromString(e)),this}},{key:"addNativeFunction",value:function(t,e){this.functionBuilder.addNativeFunction(t,e)}},{key:"destroy",value:function(){}}]),t}()},{"../core/input":29,"../core/utils":32}],9:[function(t,e,n){var r=t("../core/utils");e.exports=function(t){var e=function(){return t.run.apply(t,arguments)};return r.allPropertiesOf(t).forEach(function(n){"_"===n[0]&&"_"===n[1]||("function"==typeof t[n]?"add"===n.substring(0,3)||"set"===n.substring(0,3)?e[n]=function(){return t[n].apply(t,arguments),e}:e[n]=t[n].bind(t):(e.__defineGetter__(n,function(){return t[n]}),e.__defineSetter__(n,function(e){t[n]=e})))}),e.kernel=t,e}},{"../core/utils":32}],10:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}(),s=t("../core/utils"),a=t("./kernel-run-shortcut");e.exports=function(){function t(e,n){r(this,t),n=n||{},this.kernel=n.kernel,this.canvas=n.canvas,this.webGl=n.webGl,this.fn=null,this.functionBuilder=e,this.fnString=null,this.endianness=s.systemEndianness()}return i(t,[{key:"textureToArray",value:function(t){var e=this.createKernel(function(t){return t[this.thread.z][this.thread.y][this.thread.x]});return e(t)}},{key:"deleteTexture",value:function(t){this.webGl.deleteTexture(t.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(t,e){e=Object.assign({},e||{});var n=t.toString();return e.functionBuilder||(e.functionBuilder=this.functionBuilder),e.canvas||(e.canvas=this.canvas),e.webGl||(e.webGl=this.webgl),a(new this.Kernel(n,e))}}]),t}()},{"../core/utils":32,"./kernel-run-shortcut":9}],11:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=t("../function-builder-base"),o=t("./function-node");e.exports=function(t){function e(){r(this,e);var t=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this));return t.Node=o,t}return s(e,t),e}(a)},{"../function-builder-base":6,"./function-node":12}],12:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a(t){return t.replace(h,"((").replace(c,"((")}var o=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}}(),u=t("../web-gl/function-node"),h=/decode32\(\s+encode32\(/g,c=/encode32\(\s+decode32\(/g;e.exports=function(t){function e(){return r(this,e),i(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return s(e,t),o(e,[{key:"generate",value:function(){return this.debug&&console.log(this),this.prototypeOnly?this.astFunctionPrototype(this.getJsAST(),[]).join("").trim():(this.functionStringArray=this.astGeneric(this.getJsAST(),[]),this.functionString=a(this.functionStringArray.join("").trim()),this.functionString)}},{key:"astIdentifierExpression",value:function(t,e){if("Identifier"!==t.type)throw this.astErrorOutput("IdentifierExpression - not an Identifier",t);var n=!this.isState("in-get-call-parameters");switch(t.name){case"gpu_threadX":n&&e.push("float("),e.push("threadId.x"),n&&e.push(")");break;case"gpu_threadY":n&&e.push("float("),e.push("threadId.y"),n&&e.push(")");break;case"gpu_threadZ":n&&e.push("float("),e.push("threadId.z"),n&&e.push(")");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;case"Infinity":e.push("intBitsToFloat(2139095039)");break;default:var r=this.getUserParamName(t.name);null!==r?this.pushParameter(e,"user_"+r):this.pushParameter(e,"user_"+t.name)}return e}}]),e}(u)},{"../web-gl/function-node":19}],13:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("../web-gl/kernel"),u=t("../../core/utils"),h=t("../../core/texture"),c=t("./shader-frag"),l=t("./shader-vert");e.exports=function(t){function e(){return r(this,e),i(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return s(e,t),a(e,[{key:"initWebGl",value:function(){return u.initWebGl2(this.getCanvas())}},{key:"validateOptions",value:function(){var t=u.isFloatReadPixelsSupportedWebGL2();if(this.floatOutput===!0&&this.floatOutputForce!==!0&&!t)throw new Error("Float texture outputs are not supported on this browser");void 0===this.floatTextures&&(this.floatTextures=!0,this.floatOutput=t);var e=u.hasIntegerDivisionAccuracyBug();if(null===this.fixIntegerDivisionAccuracy?this.fixIntegerDivisionAccuracy=e:this.fixIntegerDivisionAccuracy&&!e&&(this.fixIntegerDivisionAccuracy=!1),u.checkOutput(this.output),!this.output||0===this.output.length){if(1!==arguments.length)throw new Error("Auto output only supported for kernels with only one input");var n=u.getArgumentType(arguments[0]);if("Array"===n)this.output=u.getDimensions(n);else{if("NumberTexture"!==n&&"ArrayTexture(4)"!==n)throw new Error("Auto output not supported for input type: "+n);this.output=arguments[0].output}}if(this.texSize=u.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=u.clone(this.output)}else void 0===this.floatOutput&&(this.floatOutput=!0);(this.floatOutput||this.floatOutputForce)&&this._webGl.getExtension("EXT_color_buffer_float")}},{key:"run",value:function(){null===this.program&&this.build.apply(this,arguments);var t=this.paramNames,e=this.paramTypes,n=this.texSize,r=this._webGl;r.useProgram(this.program),r.scissor(0,0,n[0],n[1]),this.hardcodeConstants||(this.setUniform3iv("uOutputDim",new Int32Array(this.threadDim)),this.setUniform2iv("uTexSize",n)),this.setUniform2f("ratio",n[0]/this.maxTexSize[0],n[1]/this.maxTexSize[1]),this.argumentsLength=0;for(var i=0;i<t.length;i++)this._addArgument(arguments[i],e[i],t[i]);if(this.constrainStart||this.constrainEnd){r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.constrainStart,this.constrainEnd;var s=[-.5,.5,0,-.5,-.5,0,.5,-.5,0,.5,.5,0],a=[3,2,1,3,1,0],o=r.createBuffer();r.bindBuffer(r.ARRAY_BUFFER,o),r.bufferData(r.ARRAY_BUFFER,new Float32Array(s),r.STATIC_DRAW),r.bindBuffer(r.ARRAY_BUFFER,null);var u=r.createBuffer();return r.bindBuffer(r.ELEMENT_ARRAY_BUFFER,u),r.bufferData(r.ELEMENT_ARRAY_BUFFER,new Uint16Array(a),r.STATIC_DRAW),r.bindBuffer(r.ELEMENT_ARRAY_BUFFER,null),r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,null),void r.drawArrays(r.TRIANGLES,0,6)}if(this.graphical)return this.outputToTexture?(r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.outputTexture&&!this.outputImmutable||this._setupOutputTexture(),r.drawArrays(r.TRIANGLE_STRIP,0,4),new h(this.outputTexture,n,this.threadDim,this.output,this._webGl,"ArrayTexture(4)")):(r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,null),void r.drawArrays(r.TRIANGLE_STRIP,0,4));r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.outputImmutable&&this._setupOutputTexture();var c=this.outputTexture;if(null!==this.subKernelOutputVariableNames&&(this.outputImmutable&&(this.subKernelOutputTextures=[],this._setupSubOutputTextures(this.subKernelOutputVariableNames.length)),r.drawBuffers(this.drawBuffersMap)),r.drawArrays(r.TRIANGLE_STRIP,0,4),null!==this.subKernelOutputTextures){if(null!==this.subKernels){var l=[];l.result=this.renderOutput(c);for(var p=0;p<this.subKernels.length;p++)l.push(new h(this.subKernelOutputTextures[p],n,this.threadDim,this.output,this._webGl));return l}if(null!==this.subKernelProperties){var f={result:this.renderOutput(c)},d=0;for(var m in this.subKernelProperties)this.subKernelProperties.hasOwnProperty(m)&&(f[m]=new h(this.subKernelOutputTextures[d],n,this.threadDim,this.output,this._webGl),d++);return f}}return this.renderOutput(c)}},{key:"getOutputTexture",value:function(){return this.outputTexture}},{key:"_setupOutputTexture",value:function(){var t=this._webGl,e=this.texSize,n=this.outputTexture=this._webGl.createTexture();t.activeTexture(t.TEXTURE0+this.constantsLength+this.paramNames.length),t.bindTexture(t.TEXTURE_2D,n),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.RGBA32F,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),t.framebufferTexture2D(t.FRAMEBUFFER,t.COLOR_ATTACHMENT0,t.TEXTURE_2D,n,0)}},{key:"_setupSubOutputTextures",value:function(t){for(var e=this._webGl,n=this.texSize,r=this.drawBuffersMap=[e.COLOR_ATTACHMENT0],i=this.subKernelOutputTextures=[],s=0;s<t;s++){var a=this._webGl.createTexture();i.push(a),r.push(e.COLOR_ATTACHMENT0+s+1),e.activeTexture(e.TEXTURE0+this.constantsLength+this.paramNames.length+s),e.bindTexture(e.TEXTURE_2D,a),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.RGBA32F,n[0],n[1],0,e.RGBA,e.FLOAT,null):e.texImage2D(e.TEXTURE_2D,0,e.RGBA,n[0],n[1],0,e.RGBA,e.UNSIGNED_BYTE,null),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0+s+1,e.TEXTURE_2D,a,0)}}},{key:"_addArgument",value:function(t,e,n){var r=this._webGl,i=this.getArgumentTexture(n);switch(t instanceof h&&(e=t.type),e){case"Array":var s=u.getDimensions(t,!0),a=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},s);r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var o=a[0]*a[1],c=this._formatArrayTransfer(t,o),l=c.valuesFlat,p=c.bitRatio,f=void 0;this.floatTextures?r.texImage2D(r.TEXTURE_2D,0,r.RGBA32F,a[0],a[1],0,r.RGBA,r.FLOAT,l):(f=new Uint8Array(l.buffer),r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0]/p,a[1],0,r.RGBA,r.UNSIGNED_BYTE,f)),this.hardcodeConstants||(this.setUniform3iv("user_"+n+"Dim",s),this.setUniform2iv("user_"+n+"Size",a)),this.setUniform1i("user_"+n+"BitRatio",p),this.setUniform1i("user_"+n,this.argumentsLength);break;case"Integer":case"Float":case"Number":this.setUniform1f("user_"+n,t);break;case"Input":var d=t,m=d.size,g=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},m);r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var y=g[0]*g[1],x=this._formatArrayTransfer(t.value,y),v=x.valuesFlat,b=x.bitRatio;if(this.floatTextures)r.texImage2D(r.TEXTURE_2D,0,r.RGBA32F,g[0],g[1],0,r.RGBA,r.FLOAT,inputArray);else{var _=new Uint8Array(v.buffer);r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0]/b,g[1],0,r.RGBA,r.UNSIGNED_BYTE,_)}this.hardcodeConstants||(this.setUniform3iv("user_"+n+"Dim",m),this.setUniform2iv("user_"+n+"Size",g)),this.setUniform1i("user_"+n+"BitRatio",b),this.setUniform1i("user_"+n,this.argumentsLength);break;case"HTMLImage":var E=t,T=[E.width,E.height,1],S=[E.width,E.height];r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var k=0,A=r.RGBA,w=r.RGBA,R=r.UNSIGNED_BYTE;r.texImage2D(r.TEXTURE_2D,k,A,w,R,E),this.setUniform3iv("user_"+n+"Dim",T),this.setUniform2iv("user_"+n+"Size",S),this.setUniform1i("user_"+n,this.argumentsLength);break;case"HTMLImageArray":var O=t,D=[O[0].width,O[0].height,O.length],C=[O[0].width,O[0].height];r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D_ARRAY,i),r.texParameteri(r.TEXTURE_2D_ARRAY,r.TEXTURE_MAG_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D_ARRAY,r.TEXTURE_MIN_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var I=0,P=r.RGBA,N=O[0].width,L=O[0].height,U=O.length,F=0,G=r.RGBA,M=r.UNSIGNED_BYTE;r.texImage3D(r.TEXTURE_2D_ARRAY,I,P,N,L,U,F,G,M,null);for(var j=0;j<O.length;j++){var B=0,V=0,X=1;r.texSubImage3D(r.TEXTURE_2D_ARRAY,I,B,V,j,O[j].width,O[j].height,X,G,M,O[j])}this.setUniform3iv("user_"+n+"Dim",D),this.setUniform2iv("user_"+n+"Size",C),this.setUniform1i("user_"+n,this.argumentsLength);break;case"ArrayTexture(4)":case"NumberTexture":var z=t,K=z.dimensions,W=z.size;r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,z.texture),this.setUniform3iv("user_"+n+"Dim",K),this.setUniform2iv("user_"+n+"Size",W),this.setUniform1i("user_"+n+"BitRatio",1),this.setUniform1i("user_"+n,this.argumentsLength);break;default:throw new Error("Input type not supported (WebGL): "+t)}this.argumentsLength++}},{key:"_getMainConstantsString",value:function(){var t=[];if(this.constants)for(var e in this.constants)if(this.constants.hasOwnProperty(e)){var n=this.constants[e],r=u.getArgumentType(n);switch(r){case"Integer":t.push("const float constants_"+e+" = "+parseInt(n)+".0");break;case"Float":t.push("const float constants_"+e+" = "+parseFloat(n));break;case"Array":case"Input":case"HTMLImage":case"ArrayTexture(4)":case"NumberTexture":t.push("uniform highp sampler2D constants_"+e,"uniform highp ivec2 constants_"+e+"Size","uniform highp ivec3 constants_"+e+"Dim","uniform highp int constants_"+e+"BitRatio");break;case"HTMLImageArray":t.push("uniform highp sampler2DArray constants_"+e,"uniform highp ivec2 constants_"+e+"Size","uniform highp ivec3 constants_"+e+"Dim","uniform highp int constants_"+e+"BitRatio");break;default:throw new Error("Unsupported constant "+e+" type "+r)}}return this._linesToString(t)}},{key:"_addConstant",value:function(t,e,n){var r=this._webGl,i=this.getArgumentTexture(n);switch(t instanceof h&&(e=t.type),e){case"Array":var s=u.getDimensions(t,!0),a=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},s);r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var o=a[0]*a[1],c=this._formatArrayTransfer(t,o),l=c.valuesFlat,p=c.bitRatio,f=void 0;this.floatTextures?r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0],a[1],0,r.RGBA,r.FLOAT,l):(f=new Uint8Array(l.buffer),r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0]/p,a[1],0,r.RGBA,r.UNSIGNED_BYTE,f)),this.hardcodeConstants||(this.setUniform3iv("constants_"+n+"Dim",s),this.setUniform2iv("constants_"+n+"Size",a)),this.setUniform1i("constants_"+n+"BitRatio",p),this.setUniform1i("constants_"+n,this.constantsLength);break;case"Input":var d=t,m=d.size,g=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},m);r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var y=g[0]*g[1],x=this._formatArrayTransfer(t.value,y),v=x.valuesFlat,b=x.bitRatio;if(this.floatTextures)r.texImage2D(r.TEXTURE_2D,0,r.RGBA32F,g[0],g[1],0,r.RGBA,r.FLOAT,inputArray);else{var _=new Uint8Array(v.buffer);r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0]/b,g[1],0,r.RGBA,r.UNSIGNED_BYTE,_)}this.hardcodeConstants||(this.setUniform3iv("constants_"+n+"Dim",m),this.setUniform2iv("constants_"+n+"Size",g)),this.setUniform1i("constants_"+n+"BitRatio",b),this.setUniform1i("constants_"+n,this.constantsLength);break;case"HTMLImage":var E=t,T=[E.width,E.height,1],S=[E.width,E.height];r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var k=0,A=r.RGBA,w=r.RGBA,R=r.UNSIGNED_BYTE;r.texImage2D(r.TEXTURE_2D,k,A,w,R,E),this.setUniform3iv("constants_"+n+"Dim",T),this.setUniform2iv("constants_"+n+"Size",S),this.setUniform1i("constants_"+n,this.constantsLength);break;case"HTMLImageArray":var O=t,D=[O[0].width,O[0].height,O.length],C=[O[0].width,O[0].height];r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D_ARRAY,i),r.texParameteri(r.TEXTURE_2D_ARRAY,r.TEXTURE_MAG_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D_ARRAY,r.TEXTURE_MIN_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var I=0,P=r.RGBA,N=O[0].width,L=O[0].height,U=O.length,F=0,G=r.RGBA,M=r.UNSIGNED_BYTE;r.texImage3D(r.TEXTURE_2D_ARRAY,I,P,N,L,U,F,G,M,null);for(var j=0;j<O.length;j++){var B=0,V=0,X=1;r.texSubImage3D(r.TEXTURE_2D_ARRAY,I,B,V,j,O[j].width,O[j].height,X,G,M,O[j])}this.setUniform3iv("constants_"+n+"Dim",D),this.setUniform2iv("constants_"+n+"Size",C),this.setUniform1i("constants_"+n,this.constantsLength);break;case"ArrayTexture(4)":case"NumberTexture":var z=t,K=z.dimensions,W=z.size;r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,z.texture),this.setUniform3iv("constants_"+n+"Dim",K),this.setUniform2iv("constants_"+n+"Size",W),this.setUniform1i("constants_"+n+"BitRatio",1),this.setUniform1i("constants_"+n,this.constantsLength);break;case"Integer":case"Float":default:throw new Error("Input type not supported (WebGL): "+t)}}},{key:"_getGetResultString",value:function(){return this.floatTextures?"  return texel[channel];":"  return decode(texel, x, bitRatio);"}},{key:"_getHeaderString",value:function(){return""}},{key:"_getTextureCoordinate",value:function(){var t=this.subKernelOutputVariableNames;return null===t||t.length<1?"in highp vec2 vTexCoord;\n":"out highp vec2 vTexCoord;\n"}},{key:"_getMainParamsString",value:function(t){for(var e=[],n=this.paramTypes,r=this.paramNames,i=0;i<r.length;i++){var s=t[i],a=r[i],o=n[i];if(this.hardcodeConstants)if("Array"===o||"NumberTexture"===o||"ArrayTexture(4)"===o){
+var h=u.getDimensions(s,!0),c=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},h);e.push("uniform highp sampler2D user_"+a,"highp ivec2 user_"+a+"Size = ivec2("+c[0]+", "+c[1]+")","highp ivec3 user_"+a+"Dim = ivec3("+h[0]+", "+h[1]+", "+h[2]+")","uniform highp int user_"+a+"BitRatio")}else"Integer"===o?e.push("highp float user_"+a+" = "+s+".0"):"Float"===o&&e.push("highp float user_"+a+" = "+s);else"Array"===o||"NumberTexture"===o||"ArrayTexture(4)"===o||"Input"===o||"HTMLImage"===o?(e.push("uniform highp sampler2D user_"+a,"uniform highp ivec2 user_"+a+"Size","uniform highp ivec3 user_"+a+"Dim"),"HTMLImage"!==o&&e.push("uniform highp int user_"+a+"BitRatio")):"HTMLImageArray"===o?e.push("uniform highp sampler2DArray user_"+a,"uniform highp ivec2 user_"+a+"Size","uniform highp ivec3 user_"+a+"Dim"):"Integer"!==o&&"Float"!==o||e.push("uniform float user_"+a)}return this._linesToString(e)}},{key:"_getKernelString",value:function(){var t=[],e=this.subKernelOutputVariableNames;if(null!==e){t.push("float kernelResult = 0.0"),t.push("layout(location = 0) out vec4 data0");for(var n=0;n<e.length;n++)t.push("float "+e[n]+" = 0.0","layout(location = "+(n+1)+") out vec4 data"+(n+1))}else t.push("out vec4 data0"),t.push("float kernelResult = 0.0");return this._linesToString(t)+this.functionBuilder.getPrototypeString("kernel")}},{key:"_getMainResultString",value:function(){var t=this.subKernelOutputVariableNames,e=[];if(this.floatOutput&&e.push("  index *= 4"),this.graphical)e.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  data0 = actualColor");else if(this.floatOutput)for(var n=["r","g","b","a"],r=0;r<n.length;++r){if(e.push("  threadId = indexTo3D(index, uOutputDim)"),e.push("  kernel()"),t){e.push("  data0."+n[r]+" = kernelResult");for(var i=0;i<t.length;++i)e.push("  data"+(i+1)+"."+n[r]+" = "+t[i])}else e.push("  data0."+n[r]+" = kernelResult");r<n.length-1&&e.push("  index += 1")}else if(null!==t){e.push("  threadId = indexTo3D(index, uOutputDim)"),e.push("  kernel()"),e.push("  data0 = encode32(kernelResult)");for(var s=0;s<t.length;s++)e.push("  data"+(s+1)+" = encode32("+t[s]+")")}else e.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  data0 = encode32(kernelResult)");return this._linesToString(e)}},{key:"_addKernels",value:function(){var t=this,e=this.functionBuilder;this._webGl;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,paramNames:this.paramNames,paramTypes:this.paramTypes,constantTypes:this.constantTypes,fixIntegerDivisionAccuracy:this.fixIntegerDivisionAccuracy}),null!==this.subKernels?(this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[],this.subKernels.forEach(function(e){return t._addSubKernel(e)})):null!==this.subKernelProperties&&(this.subKernelOutputTextures=[],this.subKernelOutputVariableNames=[],Object.keys(this.subKernelProperties).forEach(function(e){return t._addSubKernel(t.subKernelProperties[e])}))}},{key:"_getFragShaderString",value:function(t){return null!==this.compiledFragShaderString?this.compiledFragShaderString:this.compiledFragShaderString=this._replaceArtifacts(this.constructor.fragShaderString,this._getFragShaderArtifactMap(t))}},{key:"_getVertShaderString",value:function(t){return null!==this.compiledVertShaderString?this.compiledVertShaderString:this.compiledVertShaderString=this.constructor.vertShaderString}}],[{key:"fragShaderString",get:function(){return c}},{key:"vertShaderString",get:function(){return l}}]),e}(o)},{"../../core/texture":30,"../../core/utils":32,"../web-gl/kernel":21,"./shader-frag":15,"./shader-vert":16}],14:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("../runner-base"),u=t("./function-builder"),h=t("./kernel");e.exports=function(t){function e(t){r(this,e);var n=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,new u,t));return n.Kernel=h,n.kernel=null,n}return s(e,t),a(e,[{key:"getMode",value:function(){return"gpu"}}]),e}(o)},{"../runner-base":10,"./function-builder":11,"./kernel":13}],15:[function(t,e,n){e.exports="#version 300 es\n__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n\n__CONSTANTS__;\n\nin vec2 vTexCoord;\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\nfloat integerMod(float x, float y) {\n  float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nint integerMod(int x, int y) {\n  return x - (y * int(x/y));\n}\n\n__DIVIDE_WITH_INTEGER_CHECK__;\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\nfloat decode32(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\nvec4 encode32(float f) {\n  float F = abs(f);\n  float sign = f < 0.0 ? 1.0 : 0.0;\n  float exponent = floor(log2(F));\n  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\nfloat decode(vec4 rgba, int x, int bitRatio) {\n  if (bitRatio == 1) {\n    return decode32(rgba);\n  }\n  __DECODE32_ENDIANNESS__;\n  int channel = integerMod(x, bitRatio);\n  if (bitRatio == 4) {\n    return rgba[channel] * 255.0;\n  }\n  else {\n    return rgba[channel*2] * 255.0 + rgba[channel*2 + 1] * 65280.0;\n  }\n}\n\nint index;\nivec3 threadId;\n\nivec3 indexTo3D(int idx, ivec3 texDim) {\n  int z = int(idx / (texDim.x * texDim.y));\n  idx -= z * int(texDim.x * texDim.y);\n  int y = int(idx / texDim.x);\n  int x = int(integerMod(idx, texDim.x));\n  return ivec3(x, y, z);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio,  int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  vec4 texel = texture(tex, st / vec2(texSize));\n  __GET_RESULT__;\n  \n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture(tex, st / vec2(texSize));\n}\n\nvec4 getImage3D(sampler2DArray tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture(tex, vec3(st / vec2(texSize), z));\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int y, int x) {\n  return get(tex, texSize, texDim, bitRatio, 0, y, x);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int x) {\n  return get(tex, texSize, texDim, bitRatio, 0, 0, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int y, int x) {\n  return getImage2D(tex, texSize, texDim, 0, y, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int x) {\n  return getImage2D(tex, texSize, texDim, 0, 0, x);\n}\n\nvec4 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 = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}"},{}],16:[function(t,e,n){e.exports="#version 300 es\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nin vec2 aPos;\nin vec2 aTexCoord;\n\nout 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}"},{}],17:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("./kernel"),u=t("../../core/utils");e.exports=function(t){function e(){return r(this,e),i(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return s(e,t),a(e,[{key:"validateOptions",value:function(){this._webGl.getExtension("EXT_color_buffer_float"),this.texSize=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},this.output,!0)}}]),e}(o)},{"../../core/utils":32,"./kernel":13}],18:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a(t){return Math.floor(t+.5)}var o=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}}(),u=t("../function-builder-base"),h=t("./function-node");e.exports=function(t){function e(){r(this,e);var t=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this));return t.Node=h,t}return s(e,t),o(e,[{key:"polyfillStandardFunctions",value:function(){this.addFunction("round",a)}}],[{key:"round",value:function(t){return a(t)}}]),e}(u)},{"../function-builder-base":6,"./function-node":19}],19:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a(t){return t.replace(f,"((").replace(d,"((")}var o=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}}(),u=t("../function-node-base"),h=t("../../core/utils"),c="Math.",l="this.",p="this.constants.",f=/decode32\(\s+encode32\(/g,d=/encode32\(\s+decode32\(/g,m=function(){};e.exports=function(t){function e(){return r(this,e),i(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return s(e,t),o(e,[{key:"generate",value:function(){return this.debug&&m(this),this.prototypeOnly?this.astFunctionPrototype(this.getJsAST(),[]).join("").trim():(this.functionStringArray=this.astGeneric(this.getJsAST(),[]),this.functionString=a(this.functionStringArray.join("").trim()),this.functionString)}},{key:"astFunctionDeclaration",value:function(t,e){return this.builder.addFunction(null,h.getAstString(this.jsFunctionString,t)),e}},{key:"astFunctionPrototype",value:function(t,e){if(this.isRootKernel||this.isSubKernel)return e;var n=this.returnType,r=g[n];if(!r)throw new Error("unknown type "+n);e.push(r),e.push(" "),e.push(this.functionName),e.push("(");for(var i=0;i<this.paramNames.length;++i)i>0&&e.push(", "),e.push(this.paramTypes[i]),e.push(" "),e.push("user_"),e.push(this.paramNames[i]);return e.push(");\n"),e}},{key:"astFunctionExpression",value:function(t,e){if(this.isRootKernel)e.push("void");else{var n=this.returnType,r=g[n];if(!r)throw new Error("unknown type "+n);e.push(r)}if(e.push(" "),e.push(this.functionName),e.push("("),!this.isRootKernel)for(var i=0;i<this.paramNames.length;++i){var s=this.paramNames[i];i>0&&e.push(", ");var a=this.getParamType(s),o=g[a];if(!o)throw new Error("unknown type "+a);e.push(o),e.push(" "),e.push("user_"),e.push(s)}e.push(") {\n");for(var u=0;u<t.body.body.length;++u)this.astGeneric(t.body.body[u],e),e.push("\n");return e.push("}\n"),e}},{key:"astReturnStatement",value:function(t,e){return this.isRootKernel?(e.push("kernelResult = "),this.astGeneric(t.argument,e),e.push(";"),e.push("return;")):this.isSubKernel?(e.push(this.functionName+"Result = "),this.astGeneric(t.argument,e),e.push(";"),e.push("return "+this.functionName+"Result;")):(e.push("return "),this.astGeneric(t.argument,e),e.push(";")),e}},{key:"astLiteral",value:function(t,e){if(isNaN(t.value))throw this.astErrorOutput("Non-numeric literal not supported : "+t.value,t);e.push(t.value);var n=this.isState("in-get-call-parameters");return Number.isInteger(t.value)?n||e.push(".0"):n&&(e.pop(),e.push("int("),e.push(t.value),e.push(")")),e}},{key:"astBinaryExpression",value:function(t,e){var n=this.isState("in-get-call-parameters");return n&&(this.pushState("not-in-get-call-parameters"),e.push("int")),e.push("("),"%"===t.operator?(e.push("mod("),this.astGeneric(t.left,e),e.push(","),this.astGeneric(t.right,e),e.push(")")):"==="===t.operator?(this.astGeneric(t.left,e),e.push("=="),this.astGeneric(t.right,e)):"!=="===t.operator?(this.astGeneric(t.left,e),e.push("!="),this.astGeneric(t.right,e)):this.fixIntegerDivisionAccuracy&&"/"===t.operator?(e.push("div_with_int_check("),this.astGeneric(t.left,e),e.push(", "),this.astGeneric(t.right,e),e.push(")")):(this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e)),e.push(")"),n&&this.popState("not-in-get-call-parameters"),e}},{key:"astIdentifierExpression",value:function(t,e){if("Identifier"!==t.type)throw this.astErrorOutput("IdentifierExpression - not an Identifier",t);var n=!this.isState("in-get-call-parameters");switch(t.name){case"gpu_threadX":n&&e.push("float("),e.push("threadId.x"),n&&e.push(")");break;case"gpu_threadY":n&&e.push("float("),e.push("threadId.y"),n&&e.push(")");break;case"gpu_threadZ":n&&e.push("float("),e.push("threadId.z"),n&&e.push(")");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;case"Infinity":e.push("3.402823466e+38");break;default:var r=this.getUserParamName(t.name);null!==r?this.pushParameter(e,"user_"+r):this.pushParameter(e,"user_"+t.name)}return e}},{key:"astForStatement",value:function(t,e){if("ForStatement"!==t.type)throw this.astErrorOutput("Invalid for statment",t);if(t.test&&"BinaryExpression"===t.test.type){if("Identifier"===t.test.right.type&&"<"===t.test.operator&&this.isIdentifierConstant(t.test.right.name)===!1){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),this.astGeneric(t.test.left,e),e.push(t.test.operator),e.push("LOOP_MAX"),e.push(";"),this.astGeneric(t.update,e),e.push(")"),e.push("{\n"),e.push("if ("),this.astGeneric(t.test.left,e),e.push(t.test.operator),this.astGeneric(t.test.right,e),e.push(") {\n"),"BlockStatement"===t.body.type)for(var n=0;n<t.body.body.length;n++)this.astGeneric(t.body.body[n],e);else this.astGeneric(t.body,e);return e.push("\n} else {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}var r=JSON.parse(JSON.stringify(t.init.declarations)),i=t.update.argument;if(!Array.isArray(r)||r.length<1)throw m(this.jsFunctionString),new Error("Error: Incompatible for loop declaration");if(r.length>1){for(var s=null,a=0;a<r.length;a++){var o=r[a];o.id.name===i.name?(s=o,r.splice(a,1)):(e.push("float "),this.astGeneric(o,e),e.push(";"))}e.push("for (float "),this.astGeneric(s,e),e.push(";")}else e.push("for ("),this.astGeneric(t.init,e);return this.astGeneric(t.test,e),e.push(";"),this.astGeneric(t.update,e),e.push(")"),this.astGeneric(t.body,e),e}throw this.astErrorOutput("Invalid for statement",t)}},{key:"astWhileStatement",value:function(t,e){if("WhileStatement"!==t.type)throw this.astErrorOutput("Invalid while statment",t);return e.push("for (float i = 0.0; i < LOOP_MAX; i++) {"),e.push("if ("),this.astGeneric(t.test,e),e.push(") {\n"),this.astGeneric(t.body,e),e.push("} else {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}},{key:"astDoWhileStatement",value:function(t,e){if("DoWhileStatement"!==t.type)throw this.astErrorOutput("Invalid while statment",t);return e.push("for (float i = 0.0; i < LOOP_MAX; i++) {"),this.astGeneric(t.body,e),e.push("if (!"),this.astGeneric(t.test,e),e.push(") {\n"),e.push("break;\n"),e.push("}\n"),e.push("}\n"),e}},{key:"astAssignmentExpression",value:function(t,e){return"%="!==t.operator?(this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e),e):(this.astGeneric(t.left,e),e.push("="),e.push("mod("),this.astGeneric(t.left,e),e.push(","),this.astGeneric(t.right,e),e.push(")"),void 0)}},{key:"astEmptyStatement",value:function(t,e){return e}},{key:"astBlockStatement",value:function(t,e){e.push("{\n");for(var n=0;n<t.body.length;n++)this.astGeneric(t.body[n],e);return e.push("}\n"),e}},{key:"astExpressionStatement",value:function(t,e){return this.astGeneric(t.expression,e),e.push(";"),e}},{key:"astVariableDeclaration",value:function(t,e){for(var n=0;n<t.declarations.length;n++){var r=t.declarations[n];n>0&&e.push(",");var i=[];this.astGeneric(r,i);var s="Number";if(0===n){var a=r.init;if(a)if(a.object){if("MemberExpression"===a.object.type&&a.object.object)if("ThisExpression"!==a.object.object.type||!a.object.property||"thread"!==a.object.property.name&&"output"!==a.object.property.name){if("Identifier"===a.object.object.type){var o=this.getParamType(a.object.object.name);s=y[o]}else if(a.object.object.object&&"Identifier"===a.object.object.object.type){var u=this.getParamType(a.object.object.object.name);s=y[u]}else if(a.object.object.object&&a.object.object.object.object&&"ThisExpression"===a.object.object.object.object.type&&"constants"===a.object.object.object.property.name){var h=this.getConstantType(a.object.object.property.name);s=y[h]}else if(a.object.object.object&&a.object.object.object.object&&a.object.object.object.object.object&&"ThisExpression"===a.object.object.object.object.object.type&&"constants"===a.object.object.object.object.property.name){var c=this.getConstantType(a.object.object.object.property.name);s=y[c]}}else s="Integer";if(!s)throw new Error("unknown lookup type "+y)}else if(a.name&&this.declarations[a.name])s=this.declarations[a.name];else if("ArrayExpression"===a.type)s="Array("+a.elements.length+")";else if("CallExpression"===a.type){var l=this.builder.nodeMap[a.callee.name];l&&l.returnType&&(s=l.returnType)}var p=g[s];if(!p)throw new Error("type "+s+" not handled");e.push(p+" ")}this.declarations[r.id.name]=s,e.push.apply(e,i)}return e.push(";"),e}},{key:"astVariableDeclarator",value:function(t,e){return this.astGeneric(t.id,e),null!==t.init&&(e.push("="),this.astGeneric(t.init,e)),e}},{key:"astIfStatement",value:function(t,e){return e.push("if ("),this.astGeneric(t.test,e),e.push(")"),"BlockStatement"===t.consequent.type?this.astGeneric(t.consequent,e):(e.push(" {\n"),this.astGeneric(t.consequent,e),e.push("\n}\n")),t.alternate&&(e.push("else "),"BlockStatement"===t.alternate.type?this.astGeneric(t.alternate,e):(e.push(" {\n"),this.astGeneric(t.alternate,e),e.push("\n}\n"))),e}},{key:"astBreakStatement",value:function(t,e){return e.push("break;\n"),e}},{key:"astContinueStatement",value:function(t,e){return e.push("continue;\n"),e}},{key:"astLogicalExpression",value:function(t,e){return e.push("("),this.astGeneric(t.left,e),e.push(t.operator),this.astGeneric(t.right,e),e.push(")"),e}},{key:"astUpdateExpression",value:function(t,e){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e)):(this.astGeneric(t.argument,e),e.push(t.operator)),e}},{key:"astUnaryExpression",value:function(t,e){return t.prefix?(e.push(t.operator),this.astGeneric(t.argument,e)):(this.astGeneric(t.argument,e),e.push(t.operator)),e}},{key:"astThisExpression",value:function(t,e){return e.push("this"),e}},{key:"astMemberExpression",value:function(t,e){if(m("[in] astMemberExpression "+t.object.type),t.computed)if("Identifier"===t.object.type||"MemberExpression"===t.object.type&&t.object.object.object&&"ThisExpression"===t.object.object.object.type&&"constants"===t.object.object.property.name){var n=t.object.name,r=this.functionName||"kernel",i=!1;if(this.paramNames){var s=this.paramNames.indexOf(n);s>=0&&"Number"===this.paramTypes[s]&&(i=!0)}if(m("- astMemberExpression "+n+" "+r),i)this.astGeneric(t.object,e),e.push("[int("),this.astGeneric(t.property,e),e.push(")]");else{var a=this.isState("in-get-call-parameters"),o=this.isState("multi-member-expression");o&&this.popState("multi-member-expression"),this.pushState("not-in-get-call-parameters");var u=null;switch(t.object.name?u=this.declarations[t.object.name]?this.declarations[t.object.name]:this.getParamType(t.object.name):t.object&&t.object.object&&t.object.object.object&&"ThisExpression"===t.object.object.object.type&&(u=this.getConstantType(t.object.property.name)),u){case"Array(2)":case"Array(3)":case"Array(4)":this.astGeneric(t.object,e),e.push("["),e.push(t.property.raw),e.push("]"),o&&this.popState("not-in-get-call-parameters");break;case"HTMLImageArray":e.push("getImage3D("),this.astGeneric(t.object,e),e.push(", ivec2("),this.astGeneric(t.object,e),e.push("Size[0],"),this.astGeneric(t.object,e),e.push("Size[1]), ivec3("),this.astGeneric(t.object,e),e.push("Dim[0],"),this.astGeneric(t.object,e),e.push("Dim[1],"),this.astGeneric(t.object,e),e.push("Dim[2]"),e.push("), "),this.popState("not-in-get-call-parameters"),this.pushState("in-get-call-parameters"),this.astGeneric(t.property,e),o||this.popState("in-get-call-parameters"),e.push(")");break;case"ArrayTexture(4)":case"HTMLImage":e.push("getImage2D("),this.astGeneric(t.object,e),e.push(", ivec2("),this.astGeneric(t.object,e),e.push("Size[0],"),this.astGeneric(t.object,e),e.push("Size[1]), ivec3("),this.astGeneric(t.object,e),e.push("Dim[0],"),this.astGeneric(t.object,e),e.push("Dim[1],"),this.astGeneric(t.object,e),e.push("Dim[2]"),e.push("), "),this.popState("not-in-get-call-parameters"),this.pushState("in-get-call-parameters"),this.astGeneric(t.property,e),o||this.popState("in-get-call-parameters"),e.push(")");break;default:a&&e.push("int("),e.push("get("),this.astGeneric(t.object,e),e.push(", ivec2("),this.astGeneric(t.object,e),e.push("Size[0],"),this.astGeneric(t.object,e),e.push("Size[1]), ivec3("),this.astGeneric(t.object,e),e.push("Dim[0],"),this.astGeneric(t.object,e),e.push("Dim[1],"),this.astGeneric(t.object,e),e.push("Dim[2]"),e.push("), "),this.astGeneric(t.object,e),e.push("BitRatio"),e.push(", "),this.popState("not-in-get-call-parameters"),this.pushState("in-get-call-parameters"),this.astGeneric(t.property,e),o||this.popState("in-get-call-parameters"),e.push(")"),a&&e.push(")")}}}else{m("- astMemberExpression obj:",t.object);var h=(this.states.length,this.isState("in-get-call-parameters"));h||this.pushState("multi-member-expression"),this.astGeneric(t.object,e),this.isState("multi-member-expression")&&this.popState("multi-member-expression");var c=!h&&this.isState("in-get-call-parameters"),l=e.pop();e.push(","),m("- astMemberExpression prop:",t.property);var f=this.isState("should-pop-in-get-call-parameters");f&&this.popState("should-pop-in-get-call-parameters"),this.astGeneric(t.property,e),e.push(l),c?this.pushState("should-pop-in-get-call-parameters"):f&&this.popState("in-get-call-parameters")}else{var d=this.astMemberExpressionUnroll(t),g=d.toLowerCase();m("- astMemberExpression unrolled:",d),0===d.indexOf(p)&&(d="constants_"+d.slice(p.length));var y=!this.isState("in-get-call-parameters");switch(g){case"this.thread.x":y&&e.push("float("),e.push("threadId.x"),y&&e.push(")");break;case"this.thread.y":y&&e.push("float("),e.push("threadId.y"),y&&e.push(")");break;case"this.thread.z":y&&e.push("float("),e.push("threadId.z"),y&&e.push(")");break;case"this.output.x":e.push(this.output[0]+".0");break;case"this.output.y":e.push(this.output[1]+".0");break;case"this.output.z":e.push(this.output[2]+".0");break;default:t.object&&t.object.name&&this.declarations[t.object.name]&&e.push("user_"),e.push(d)}}return m("[out] astMemberExpression "+t.object.type),e}},{key:"astSequenceExpression",value:function(t,e){for(var n=0;n<t.expressions.length;n++)n>0&&e.push(","),this.astGeneric(t.expressions,e);return e}},{key:"astCallExpression",value:function(t,e){if(t.callee){var n=this.astMemberExpressionUnroll(t.callee);0===n.indexOf(c)&&(n=n.slice(c.length)),0===n.indexOf(l)&&(n=n.slice(l.length)),"atan2"===n&&(n="atan"),this.calledFunctions.indexOf(n)<0&&this.calledFunctions.push(n),this.hasOwnProperty("funcName")||(this.calledFunctionsArguments[n]=[]);var r=[];this.calledFunctionsArguments[n].push(r),e.push(n),e.push("(");for(var i=0;i<t.arguments.length;++i){var s=t.arguments[i];if(i>0&&e.push(", "),this.astGeneric(s,e),"Identifier"===s.type){var a=this.paramNames.indexOf(s.name);a===-1?r.push(null):r.push({name:s.name,type:this.paramTypes[a]||"Number"})}else r.push(null)}return e.push(")"),e}throw this.astErrorOutput("Unknown CallExpression",t)}},{key:"astArrayExpression",value:function(t,e){var n=t.elements.length;e.push("vec"+n+"(");for(var r=0;r<n;++r){r>0&&e.push(", ");var i=t.elements[r];this.astGeneric(i,e)}return e.push(")"),e}},{key:"getFunctionPrototypeString",value:function(){return this.webGlFunctionPrototypeString?this.webGlFunctionPrototypeString:this.webGlFunctionPrototypeString=this.generate()}},{key:"build",value:function(){return this.getFunctionPrototypeString().length>0}}]),e}(u);var g={Array:"sampler2D","Array(2)":"vec2","Array(3)":"vec3","Array(4)":"vec4",Array2D:"sampler2D",Array3D:"sampler2D",Float:"float",Input:"sampler2D",Integer:"float",Number:"float",NumberTexture:"sampler2D","ArrayTexture(4)":"sampler2D"},y={Array:"Number",Array2D:"Number",Array3D:"Number",HTMLImage:"Array(4)",HTMLImageArray:"Array(4)",NumberTexture:"Number","ArrayTexture(4)":"Array(4)"}},{"../../core/utils":32,"../function-node-base":7}],20:[function(t,e,n){function r(t){return/^function /.test(t)&&(t=t.substring(9)),t.replace(/[_]typeof/g,"typeof")}function i(t){return t.replace(/[_]typeof/g,"typeof")}var s=t("../../core/utils"),a=t("../kernel-run-shortcut");t("../../core/input"),t("../../core/texture");e.exports=function(t,e){return"() => {\n    "+a.toString()+";\n    const utils = {\n      allPropertiesOf: "+i(s.allPropertiesOf.toString())+",\n      clone: "+i(s.clone.toString())+",\n      splitArray: "+i(s.splitArray.toString())+",\n      getArgumentType: "+i(s.getArgumentType.toString())+",\n      getDimensions: "+i(s.getDimensions.toString())+",\n      dimToTexSize: "+i(s.dimToTexSize.toString())+",\n      flattenTo: "+i(s.flattenTo.toString())+",\n      flatten2dArrayTo: "+i(s.flatten2dArrayTo.toString())+",\n      flatten3dArrayTo: "+i(s.flatten3dArrayTo.toString())+",\n      systemEndianness: '"+i(s.systemEndianness())+"',\n      initWebGl: "+i(s.initWebGl.toString())+",\n      isArray: "+i(s.isArray.toString())+",\n      checkOutput: "+i(s.checkOutput.toString())+"\n    };\n    const Utils = utils;\n    const canvases = [];\n    const maxTexSizes = {};\n    let Texture = function() {};\n    let Input = function() {}; \n    class "+(e||"Kernel")+" {\n      constructor() {\n        this.maxTexSize = null;\n        this.argumentsLength = 0;\n        this.constantsLength = 0;\n        this._canvas = null;\n        this._webGl = null;\n        this.program = null;\n        this.outputToTexture = "+(t.outputToTexture?"true":"false")+";\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\t\t    this.subKernelOutputVariableNames = null;\n\t\t    this.uniform1fCache = {};\n\t\t    this.uniform1iCache = {};\n\t\t    this.uniform2fCache = {};\n\t\t    this.uniform2fvCache = {};\n\t\t    this.uniform2ivCache = {};\n\t\t    this.uniform3fvCache = {};\n\t\t    this.uniform3ivCache = {};\n      }\n      _getFragShaderString() { return this.compiledFragShaderString; }\n      _getVertShaderString() { return this.compiledVertShaderString; }\n      validateOptions() {}\n      setupParams() {}\n      setupConstants() {}\n      setCanvas(canvas) { this._canvas = canvas; return this; }\n      setWebGl(webGl) { this._webGl = webGl; return this; }\n      setTexture(Type) { Texture = Type; }\n      setInput(Type) { Input = Type; }\n      "+r(t.getUniformLocation.toString())+"\n      "+r(t.build.toString())+"\n\t\t  "+r(t.run.toString())+"\n\t\t  "+r(t._addArgument.toString())+"\n\t\t  "+r(t._formatArrayTransfer.toString())+"\n\t\t  "+r(t.getArgumentTexture.toString())+"\n\t\t  "+r(t.getTextureCache.toString())+"\n\t\t  "+r(t.getOutputTexture.toString())+"\n\t\t  "+r(t.renderOutput.toString())+"\n\t\t  "+r(t.updateMaxTexSize.toString())+"\n\t\t  "+r(t._setupOutputTexture.toString())+"\n\t\t  "+r(t.detachTextureCache.toString())+"\n\t\t  "+r(t.setUniform1f.toString())+"\n\t\t  "+r(t.setUniform1i.toString())+"\n\t\t  "+r(t.setUniform2f.toString())+"\n\t\t  "+r(t.setUniform2fv.toString())+"\n\t\t  "+r(t.setUniform2iv.toString())+"\n\t\t  "+r(t.setUniform3fv.toString())+"\n\t\t  "+r(t.setUniform3iv.toString())+"\n    };\n    return kernelRunShortcut(new Kernel());\n  };";
+}},{"../../core/input":29,"../../core/texture":30,"../../core/utils":32,"../kernel-run-shortcut":9}],21:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=function g(t,e,n){null===t&&(t=Function.prototype);var r=Object.getOwnPropertyDescriptor(t,e);if(void 0===r){var i=Object.getPrototypeOf(t);return null===i?void 0:g(i,e,n)}if("value"in r)return r.value;var s=r.get;if(void 0!==s)return s.call(n)},o=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}}(),u=t("../kernel-base"),h=t("../../core/utils"),c=t("../../core/texture"),l=t("./shader-frag"),p=t("./shader-vert"),f=t("./kernel-string"),d=[],m={};e.exports=function(t){function e(t,n){r(this,e);var s=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t,n));return s.textureCache={},s.threadDim={},s.programUniformLocationCache={},s.framebuffer=null,s.buffer=null,s.program=null,s.outputToTexture=n.outputToTexture,s.endianness=h.systemEndianness(),s.subKernelOutputTextures=null,s.subKernelOutputVariableNames=null,s.argumentsLength=0,s.constantsLength=0,s.compiledFragShaderString=null,s.compiledVertShaderString=null,s.fragShader=null,s.vertShader=null,s.drawBuffersMap=null,s.outputTexture=null,s.maxTexSize=null,s.uniform1fCache={},s.uniform1iCache={},s.uniform2fCache={},s.uniform2fvCache={},s.uniform2ivCache={},s.uniform3fvCache={},s.uniform3ivCache={},s._webGl||(s._webGl=s.initWebGl()),s}return s(e,t),o(e,null,[{key:"fragShaderString",get:function(){return l}},{key:"vertShaderString",get:function(){return p}}]),o(e,[{key:"initWebGl",value:function(){return h.initWebGl(this.getCanvas())}},{key:"validateOptions",value:function(){var t=h.isFloatReadPixelsSupported();if(this.floatTextures===!0&&!h.OES_texture_float)throw new Error("Float textures are not supported on this browser");if(this.floatOutput===!0&&this.floatOutputForce!==!0&&!t)throw new Error("Float texture outputs are not supported on this browser");void 0===this.floatTextures&&h.OES_texture_float&&(this.floatTextures=!0,this.floatOutput=t);var e=h.hasIntegerDivisionAccuracyBug();if(null===this.fixIntegerDivisionAccuracy?this.fixIntegerDivisionAccuracy=e:this.fixIntegerDivisionAccuracy&&!e&&(this.fixIntegerDivisionAccuracy=!1),h.checkOutput(this.output),!this.output||0===this.output.length){if(1!==arguments.length)throw new Error("Auto output only supported for kernels with only one input");var n=h.getArgumentType(arguments[0]);if("Array"===n)this.output=h.getDimensions(n);else{if("NumberTexture"!==n&&"ArrayTexture(4)"!==n)throw new Error("Auto output not supported for input type: "+n);this.output=arguments[0].output}}if(this.texSize=h.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=h.clone(this.output)}else void 0===this.floatOutput&&h.OES_texture_float&&(this.floatOutput=!0)}},{key:"updateMaxTexSize",value:function(){var t=this.texSize,e=this._canvas;if(null===this.maxTexSize){var n=d.indexOf(e);n===-1&&(n=d.length,d.push(e),m[n]=[t[0],t[1]]),this.maxTexSize=m[n]}this.maxTexSize[0]<t[0]&&(this.maxTexSize[0]=t[0]),this.maxTexSize[1]<t[1]&&(this.maxTexSize[1]=t[1])}},{key:"build",value:function(){this.validateOptions(),this.setupConstants(),this.setupParams(arguments),this.updateMaxTexSize();var t=this.texSize,e=this._webGl,n=this._canvas;e.enable(e.SCISSOR_TEST),e.viewport(0,0,this.maxTexSize[0],this.maxTexSize[1]),n.width=this.maxTexSize[0],n.height=this.maxTexSize[1];for(var r=this.threadDim=h.clone(this.output);r.length<3;)r.push(1);this.functionBuilder&&this._addKernels();var i=this._getVertShaderString(arguments),s=e.createShader(e.VERTEX_SHADER);e.shaderSource(s,i),e.compileShader(s),this.vertShader=s;var a=this._getFragShaderString(arguments),o=e.createShader(e.FRAGMENT_SHADER);if(e.shaderSource(o,a),e.compileShader(o),this.fragShader=o,!e.getShaderParameter(s,e.COMPILE_STATUS))throw console.log(i),console.error("An error occurred compiling the shaders: "+e.getShaderInfoLog(s)),new Error("Error compiling vertex shader");if(!e.getShaderParameter(o,e.COMPILE_STATUS))throw console.log(a),console.error("An error occurred compiling the shaders: "+e.getShaderInfoLog(o)),new Error("Error compiling fragment shader");this.debug&&(console.log("Options:"),console.dir(this),console.log("GLSL Shader Output:"),console.log(a));var u=this.program=e.createProgram();e.attachShader(u,s),e.attachShader(u,o),e.linkProgram(u),this.framebuffer=e.createFramebuffer(),this.framebuffer.width=t[0],this.framebuffer.height=t[1];var c=new Float32Array([-1,-1,1,-1,-1,1,1,1]),l=new Float32Array([0,0,1,0,0,1,1,1]),p=c.byteLength,f=this.buffer;f?e.bindBuffer(e.ARRAY_BUFFER,f):(f=this.buffer=e.createBuffer(),e.bindBuffer(e.ARRAY_BUFFER,f),e.bufferData(e.ARRAY_BUFFER,c.byteLength+l.byteLength,e.STATIC_DRAW)),e.bufferSubData(e.ARRAY_BUFFER,0,c),e.bufferSubData(e.ARRAY_BUFFER,p,l);var d=e.getAttribLocation(this.program,"aPos");e.enableVertexAttribArray(d),e.vertexAttribPointer(d,2,e.FLOAT,e.FALSE,0,0);var m=e.getAttribLocation(this.program,"aTexCoord");e.enableVertexAttribArray(m),e.vertexAttribPointer(m,2,e.FLOAT,e.FALSE,0,p),e.bindFramebuffer(e.FRAMEBUFFER,this.framebuffer);for(var g in this.constants){var y=this.constants[g],x=h.getArgumentType(y);"Float"!==x&&"Integer"!==x&&(e.useProgram(this.program),this._addConstant(this.constants[g],x,g),this.constantsLength++)}this.outputImmutable||(this._setupOutputTexture(),null!==this.subKernelOutputVariableNames&&this.subKernelOutputVariableNames.length>0&&this._setupSubOutputTextures(this.subKernelOutputVariableNames.length))}},{key:"run",value:function(){null===this.program&&this.build.apply(this,arguments);var t=this.paramNames,e=this.paramTypes,n=this.texSize,r=this._webGl;r.useProgram(this.program),r.scissor(0,0,n[0],n[1]),this.hardcodeConstants||(this.setUniform3iv("uOutputDim",this.threadDim),this.setUniform2iv("uTexSize",n)),this.setUniform2f("ratio",n[0]/this.maxTexSize[0],n[1]/this.maxTexSize[1]),this.argumentsLength=0;for(var i=0;i<t.length;i++)this._addArgument(arguments[i],e[i],t[i]);if(this.constrainStart||this.constrainEnd){r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.constrainStart,this.constrainEnd;var s=[-.5,.5,0,-.5,-.5,0,.5,-.5,0,.5,.5,0],a=[3,2,1,3,1,0],o=r.createBuffer();r.bindBuffer(r.ARRAY_BUFFER,o),r.bufferData(r.ARRAY_BUFFER,new Float32Array(s),r.STATIC_DRAW),r.bindBuffer(r.ARRAY_BUFFER,null);var u=r.createBuffer();return r.bindBuffer(r.ELEMENT_ARRAY_BUFFER,u),r.bufferData(r.ELEMENT_ARRAY_BUFFER,new Uint16Array(a),r.STATIC_DRAW),r.bindBuffer(r.ELEMENT_ARRAY_BUFFER,null),r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,null),r.drawArrays(r.TRIANGLES,0,6),this._setupOutputTexture(),this.renderOutput(this.outputTexture)}if(this.graphical)return this.outputToTexture?(r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.outputTexture&&!this.outputImmutable||this._setupOutputTexture(),r.drawArrays(r.TRIANGLE_STRIP,0,4),new c(this.outputTexture,n,this.threadDim,this.output,this._webGl,"ArrayTexture(4)")):(r.bindRenderbuffer(r.RENDERBUFFER,null),r.bindFramebuffer(r.FRAMEBUFFER,null),void r.drawArrays(r.TRIANGLE_STRIP,0,4));r.bindFramebuffer(r.FRAMEBUFFER,this.framebuffer),this.outputImmutable&&this._setupOutputTexture();var h=this.outputTexture;if(null!==this.subKernelOutputVariableNames&&(this.outputImmutable&&(this.subKernelOutputTextures=[],this._setupSubOutputTextures(this.subKernelOutputVariableNames.length)),this.drawBuffers.drawBuffersWEBGL(this.drawBuffersMap)),r.drawArrays(r.TRIANGLE_STRIP,0,4),null!==this.subKernelOutputTextures){if(null!==this.subKernels){var l=[];l.result=this.renderOutput(h);for(var p=0;p<this.subKernels.length;p++)l.push(new c(this.subKernelOutputTextures[p],n,this.threadDim,this.output,this._webGl));return l}if(null!==this.subKernelProperties){var f={result:this.renderOutput(h)},d=0;for(var m in this.subKernelProperties)this.subKernelProperties.hasOwnProperty(m)&&(f[m]=new c(this.subKernelOutputTextures[d],n,this.threadDim,this.output,this._webGl),d++);return f}}return this.renderOutput(h)}},{key:"renderOutput",value:function(t){var e=this.texSize,n=this._webGl,r=this.threadDim,i=this.output;if(this.outputToTexture)return new c(t,e,this.threadDim,i,this._webGl);var s=void 0;if(this.floatOutput){var a=e[0],o=Math.ceil(e[1]/4);s=new Float32Array(a*o*4),n.readPixels(0,0,a,o,n.RGBA,n.FLOAT,s)}else{var u=new Uint8Array(e[0]*e[1]*4);n.readPixels(0,0,e[0],e[1],n.RGBA,n.UNSIGNED_BYTE,u),s=new Float32Array(u.buffer)}if(s=s.subarray(0,r[0]*r[1]*r[2]),1===i.length)return s;if(2===i.length)return h.splitArray(s,i[0]);if(3===i.length){var l=h.splitArray(s,i[0]*i[1]);return l.map(function(t){return h.splitArray(t,i[0])})}}},{key:"getOutputTexture",value:function(){return this.outputTexture}},{key:"_setupOutputTexture",value:function(){var t=this._webGl,e=this.texSize,n=this.outputTexture=this._webGl.createTexture();t.activeTexture(t.TEXTURE0+this.constantsLength+this.paramNames.length),t.bindTexture(t.TEXTURE_2D,n),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),t.framebufferTexture2D(t.FRAMEBUFFER,t.COLOR_ATTACHMENT0,t.TEXTURE_2D,n,0)}},{key:"_setupSubOutputTextures",value:function(t){for(var e=this._webGl,n=this.texSize,r=this.drawBuffersMap=[e.COLOR_ATTACHMENT0],i=this.subKernelOutputTextures=[],s=0;s<t;s++){var a=this._webGl.createTexture();i.push(a),r.push(e.COLOR_ATTACHMENT0+s+1),e.activeTexture(e.TEXTURE0+this.constantsLength+this.paramNames.length+s),e.bindTexture(e.TEXTURE_2D,a),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,n[0],n[1],0,e.RGBA,e.FLOAT,null):e.texImage2D(e.TEXTURE_2D,0,e.RGBA,n[0],n[1],0,e.RGBA,e.UNSIGNED_BYTE,null),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0+s+1,e.TEXTURE_2D,a,0)}}},{key:"getArgumentTexture",value:function(t){return this.getTextureCache("ARGUMENT_"+t)}},{key:"getTextureCache",value:function(t){return this.textureCache.hasOwnProperty(t)?this.textureCache[t]:this.textureCache[t]=this._webGl.createTexture()}},{key:"detachTextureCache",value:function(t){delete this.textureCache[t]}},{key:"setUniform1f",value:function(t,e){if(this.uniform1fCache.hasOwnProperty(t)){var n=this.uniform1fCache[t];if(e===n)return}this.uniform1fCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform1f(r,e)}},{key:"setUniform1i",value:function(t,e){if(this.uniform1iCache.hasOwnProperty(t)){var n=this.uniform1iCache[t];if(e===n)return}this.uniform1iCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform1i(r,e)}},{key:"setUniform2f",value:function(t,e,n){if(this.uniform2fCache.hasOwnProperty(t)){var r=this.uniform2fCache[t];if(e===r[0]&&n===r[1])return}this.uniform2fCache[t]=[e,n];var i=this.getUniformLocation(t);this._webGl.uniform2f(i,e,n)}},{key:"setUniform2fv",value:function(t,e){if(this.uniform2fvCache.hasOwnProperty(t)){var n=this.uniform2fvCache[t];if(e[0]===n[0]&&e[1]===n[1])return}this.uniform2fvCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform2fv(r,e)}},{key:"setUniform2iv",value:function(t,e){if(this.uniform2ivCache.hasOwnProperty(t)){var n=this.uniform2ivCache[t];if(e[0]===n[0]&&e[1]===n[1])return}this.uniform2ivCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform2iv(r,e)}},{key:"setUniform3fv",value:function(t,e){if(this.uniform3fvCache.hasOwnProperty(t)){var n=this.uniform3fvCache[t];if(e[0]===n[0]&&e[1]===n[1]&&e[2]===n[2])return}this.uniform3fvCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform3fv(r,e)}},{key:"setUniform3iv",value:function(t,e){if(this.uniform3ivCache.hasOwnProperty(t)){var n=this.uniform3ivCache[t];if(e[0]===n[0]&&e[1]===n[1]&&e[2]===n[2])return}this.uniform3ivCache[t]=e;var r=this.getUniformLocation(t);this._webGl.uniform3iv(r,e)}},{key:"getUniformLocation",value:function(t){return this.programUniformLocationCache.hasOwnProperty(t)?this.programUniformLocationCache[t]:this.programUniformLocationCache[t]=this._webGl.getUniformLocation(this.program,t)}},{key:"_getFragShaderArtifactMap",value:function(t){return{HEADER:this._getHeaderString(),LOOP_MAX:this._getLoopMaxString(),CONSTANTS:this._getConstantsString(),DECODE32_ENDIANNESS:this._getDecode32EndiannessString(),ENCODE32_ENDIANNESS:this._getEncode32EndiannessString(),DIVIDE_WITH_INTEGER_CHECK:this._getDivideWithIntegerCheckString(),GET_WRAPAROUND:this._getGetWraparoundString(),GET_TEXTURE_CHANNEL:this._getGetTextureChannelString(),GET_TEXTURE_INDEX:this._getGetTextureIndexString(),GET_RESULT:this._getGetResultString(),MAIN_PARAMS:this._getMainParamsString(t),MAIN_CONSTANTS:this._getMainConstantsString(),KERNEL:this._getKernelString(),MAIN_RESULT:this._getMainResultString()}}},{key:"_addArgument",value:function(t,e,n){var r=this._webGl,i=this.getArgumentTexture(n);switch(t instanceof c&&(e=t.type),e){case"Array":case"Array(2)":case"Array(3)":case"Array(4)":case"Array2D":case"Array3D":var s=h.getDimensions(t,!0),a=h.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},s);r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var o=a[0]*a[1],u=this._formatArrayTransfer(t,o),l=u.valuesFlat,p=u.bitRatio,f=void 0;this.floatTextures?r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0],a[1],0,r.RGBA,r.FLOAT,l):(f=new Uint8Array(l.buffer),r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0]/p,a[1],0,r.RGBA,r.UNSIGNED_BYTE,f)),this.hardcodeConstants||(this.setUniform3iv("user_"+n+"Dim",s),this.setUniform2iv("user_"+n+"Size",a)),this.setUniform1i("user_"+n+"BitRatio",p),this.setUniform1i("user_"+n,this.argumentsLength);break;case"Integer":case"Float":case"Number":this.setUniform1f("user_"+n,t);break;case"Input":var d=t,m=d.size,g=h.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},m);r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var y=g[0]*g[1],x=this._formatArrayTransfer(t.value,y),v=x.valuesFlat,b=x.bitRatio;if(this.floatTextures)r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0],g[1],0,r.RGBA,r.FLOAT,inputArray);else{var _=new Uint8Array(v.buffer);r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0]/b,g[1],0,r.RGBA,r.UNSIGNED_BYTE,_)}this.hardcodeConstants||(this.setUniform3iv("user_"+n+"Dim",m),this.setUniform2iv("user_"+n+"Size",g)),this.setUniform1i("user_"+n+"BitRatio",b),this.setUniform1i("user_"+n,this.argumentsLength);break;case"HTMLImage":var E=t,T=[E.width,E.height,1],S=[E.width,E.height];r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var k=0,A=r.RGBA,w=r.RGBA,R=r.UNSIGNED_BYTE;r.texImage2D(r.TEXTURE_2D,k,A,w,R,E),this.setUniform3iv("user_"+n+"Dim",T),this.setUniform2iv("user_"+n+"Size",S),this.setUniform1i("user_"+n,this.argumentsLength);break;case"ArrayTexture(4)":case"NumberTexture":var O=t,D=O.dimensions,C=O.size;r.activeTexture(r.TEXTURE0+this.constantsLength+this.argumentsLength),r.bindTexture(r.TEXTURE_2D,O.texture),this.setUniform3iv("user_"+n+"Dim",D),this.setUniform2iv("user_"+n+"Size",C),this.setUniform1i("user_"+n+"BitRatio",1),this.setUniform1i("user_"+n,this.argumentsLength);break;default:throw new Error("Input type not supported (WebGL): "+t)}this.argumentsLength++}},{key:"_addConstant",value:function(t,e,n){var r=this._webGl,i=this.getArgumentTexture(n);switch(t instanceof c&&(e=t.type),e){case"Array":var s=h.getDimensions(t,!0),a=h.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},s);r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var o=a[0]*a[1],u=this._formatArrayTransfer(t,o),l=u.valuesFlat,p=u.bitRatio,f=void 0;this.floatTextures?r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0],a[1],0,r.RGBA,r.FLOAT,l):(f=new Uint8Array(l.buffer),r.texImage2D(r.TEXTURE_2D,0,r.RGBA,a[0]/p,a[1],0,r.RGBA,r.UNSIGNED_BYTE,f)),this.hardcodeConstants||(this.setUniform3iv("constants_"+n+"Dim",s),this.setUniform2iv("constants_"+n+"Size",a)),this.setUniform1i("constants_"+n+"BitRatio",p),this.setUniform1i("constants_"+n,this.constantsLength);break;case"Input":var d=t,m=d.size,g=h.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},m);r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST);var y=g[0]*g[1],x=this._formatArrayTransfer(t.value,y),v=x.valuesFlat,b=x.bitRatio;if(this.floatTextures)r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0],g[1],0,r.RGBA,r.FLOAT,inputArray);else{var _=new Uint8Array(v.buffer);r.texImage2D(r.TEXTURE_2D,0,r.RGBA,g[0]/b,g[1],0,r.RGBA,r.UNSIGNED_BYTE,_)}this.hardcodeConstants||(this.setUniform3iv("constants_"+n+"Dim",m),this.setUniform2iv("constants_"+n+"Size",g)),this.setUniform1i("constants_"+n+"BitRatio",b),this.setUniform1i("constants_"+n,this.constantsLength);break;case"HTMLImage":var E=t,T=[E.width,E.height,1],S=[E.width,E.height];r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,i),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL,!0);var k=0,A=r.RGBA,w=r.RGBA,R=r.UNSIGNED_BYTE;r.texImage2D(r.TEXTURE_2D,k,A,w,R,E),this.setUniform3iv("constants_"+n+"Dim",T),this.setUniform2iv("constants_"+n+"Size",S),this.setUniform1i("constants_"+n,this.constantsLength);break;case"ArrayTexture(4)":case"NumberTexture":var O=t,D=O.dimensions,C=O.size;r.activeTexture(r.TEXTURE0+this.constantsLength),r.bindTexture(r.TEXTURE_2D,O.texture),this.setUniform3iv("constants_"+n+"Dim",D),this.setUniform2iv("constants_"+n+"Size",C),this.setUniform1i("constants_"+n+"BitRatio",1),this.setUniform1i("constants_"+n,this.constantsLength);break;case"Integer":case"Float":default:throw new Error("Input type not supported (WebGL): "+t)}}},{key:"_formatArrayTransfer",value:function(t,e){var n=1,r=t;if(h.isArray(t[0])||this.floatTextures)r=new Float32Array(e),h.flattenTo(t,r);else switch(t.constructor){case Uint8Array:case Int8Array:n=4;break;case Uint16Array:case Int16Array:n=2;case Float32Array:case Int32Array:break;default:r=new Float32Array(e),h.flattenTo(t,r)}return{bitRatio:n,valuesFlat:r}}},{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 t=[],e=this.threadDim,n=this.texSize;return this.hardcodeConstants?t.push("ivec3 uOutputDim = ivec3("+e[0]+","+e[1]+", "+e[2]+")","ivec2 uTexSize = ivec2("+n[0]+", "+n[1]+")"):t.push("uniform ivec3 uOutputDim","uniform ivec2 uTexSize"),this._linesToString(t)}},{key:"_getTextureCoordinate",value:function(){var t=this.subKernelOutputVariableNames;return null===t||t.length<1?"varying vec2 vTexCoord;\n":"out 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:"_getDivideWithIntegerCheckString",value:function(){return this.fixIntegerDivisionAccuracy?"\n\t\t\t  float div_with_int_check(float x, float y) {\n\t\t\t  if (floor(x) == x && floor(y) == y && integerMod(x, y) == 0.0) {\n\t\t\t    return float(int(x)/int(y));\n\t\t\t  }\n\t\t\t  return x / y;\n\t\t\t}\n\t\t\t":""}},{key:"_getGetWraparoundString",value:function(){return this.wraparound?"  xyz = mod(xyz, texDim);\n":""}},{key:"_getGetTextureChannelString",value:function(){return this.floatTextures?this._linesToString(["  int channel = integerMod(index, 4)","  index = index / 4"]):""}},{key:"_getGetTextureIndexString",value:function(){return this.floatTextures?"  index = 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 decode(texel, x, bitRatio);"}},{key:"_getMainParamsString",value:function(t){for(var e=[],n=this.paramTypes,r=this.paramNames,i=0;i<r.length;i++){var s=t[i],a=r[i],o=n[i];if(this.hardcodeConstants)if("Array"===o||"NumberTexture"===o||"ArrayTexture(4)"===o){var u=h.getDimensions(s,!0),c=h.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},u);e.push("uniform sampler2D user_"+a,"ivec2 user_"+a+"Size = ivec2("+c[0]+", "+c[1]+")","ivec3 user_"+a+"Dim = ivec3("+u[0]+", "+u[1]+", "+u[2]+")","uniform int user_"+a+"BitRatio")}else"Integer"===o?e.push("float user_"+a+" = "+s+".0"):"Float"===o&&e.push("float user_"+a+" = "+s);else if("Array"===o||"NumberTexture"===o||"ArrayTexture(4)"===o||"Input"===o||"HTMLImage"===o)e.push("uniform sampler2D user_"+a,"uniform ivec2 user_"+a+"Size","uniform ivec3 user_"+a+"Dim"),"HTMLImage"!==o&&e.push("uniform int user_"+a+"BitRatio");else{if("Integer"!==o&&"Float"!==o)throw new Error("Param type "+o+" not supported in WebGL, only WebGL2");e.push("uniform float user_"+a)}}return this._linesToString(e)}},{key:"_getMainConstantsString",value:function(){var t=[];if(this.constants)for(var e in this.constants)if(this.constants.hasOwnProperty(e)){var n=this.constants[e],r=h.getArgumentType(n);switch(r){case"Integer":t.push("const float constants_"+e+" = "+parseInt(n)+".0");break;case"Float":t.push("const float constants_"+e+" = "+parseFloat(n));break;case"Array":case"Input":case"HTMLImage":case"NumberTexture":case"ArrayTexture(4)":t.push("uniform sampler2D constants_"+e,"uniform ivec2 constants_"+e+"Size","uniform ivec3 constants_"+e+"Dim","uniform int constants_"+e+"BitRatio");break;default:throw new Error("Unsupported constant "+e+" type "+r)}}return this._linesToString(t)}},{key:"_getKernelString",value:function(){var t=[],e=this.subKernelOutputVariableNames;if(null!==e){t.push("float kernelResult = 0.0");for(var n=0;n<e.length;n++)t.push("float "+e[n]+" = 0.0")}else t.push("float kernelResult = 0.0");return this._linesToString(t)+this.functionBuilder.getPrototypeString("kernel")}},{key:"_getMainResultString",value:function(){var t=this.subKernelOutputVariableNames,e=[];if(this.floatOutput&&e.push("  index *= 4"),this.graphical)e.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  gl_FragColor = actualColor");else if(this.floatOutput)for(var n=["r","g","b","a"],r=0;r<n.length;++r){if(e.push("  threadId = indexTo3D(index, uOutputDim)"),e.push("  kernel()"),t){e.push("  gl_FragData[0]."+n[r]+" = kernelResult");for(var i=0;i<t.length;++i)e.push("  gl_FragData["+(i+1)+"]."+n[r]+" = "+t[i])}else e.push("  gl_FragColor."+n[r]+" = kernelResult");r<n.length-1&&e.push("  index += 1")}else if(null!==t){e.push("  threadId = indexTo3D(index, uOutputDim)"),e.push("  kernel()"),e.push("  gl_FragData[0] = encode32(kernelResult)");for(var s=0;s<t.length;s++)e.push("  gl_FragData["+(s+1)+"] = encode32("+t[s]+")")}else e.push("  threadId = indexTo3D(index, uOutputDim)","  kernel()","  gl_FragColor = encode32(kernelResult)");return this._linesToString(e)}},{key:"_linesToString",value:function(t){return t.length>0?t.join(";\n")+";\n":"\n"}},{key:"_replaceArtifacts",value:function(t,e){return t.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z])*)__;\n/g,function(t,n){if(e.hasOwnProperty(n))return e[n];throw"unhandled artifact "+n})}},{key:"_addKernels",value:function(){var t=this,e=this.functionBuilder,n=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,paramNames:this.paramNames,paramTypes:this.paramTypes,constantTypes:this.constantTypes,fixIntegerDivisionAccuracy:this.fixIntegerDivisionAccuracy}),null!==this.subKernels){var r=this.drawBuffers=n.getExtension("WEBGL_draw_buffers");if(!r)throw new Error("could not instantiate draw buffers extension");this.subKernelOutputVariableNames=[],this.subKernels.forEach(function(e){return t._addSubKernel(e)})}else if(null!==this.subKernelProperties){var i=this.drawBuffers=n.getExtension("WEBGL_draw_buffers");if(!i)throw new Error("could not instantiate draw buffers extension");this.subKernelOutputVariableNames=[],Object.keys(this.subKernelProperties).forEach(function(e){return t._addSubKernel(t.subKernelProperties[e])})}}},{key:"_addSubKernel",value:function(t){this.functionBuilder.addSubKernel(t,{prototypeOnly:!1,constants:this.constants,output:this.output,debug:this.debug,loopMaxIterations:this.loopMaxIterations,fixIntegerDivisionAccuracy:this.fixIntegerDivisionAccuracy}),this.subKernelOutputVariableNames.push(t.name+"Result")}},{key:"_getFragShaderString",value:function(t){return null!==this.compiledFragShaderString?this.compiledFragShaderString:this.compiledFragShaderString=this._replaceArtifacts(this.constructor.fragShaderString,this._getFragShaderArtifactMap(t))}},{key:"_getVertShaderString",value:function(t){return null!==this.compiledVertShaderString?this.compiledVertShaderString:this.compiledVertShaderString=this.constructor.vertShaderString}},{key:"toString",value:function(){return f(this)}},{key:"addFunction",value:function(t){this.functionBuilder.addFunction(null,t)}},{key:"destroy",value:function(t){a(e.prototype.__proto__||Object.getPrototypeOf(e.prototype),"destroy",this).call(this),this.outputTexture&&this._webGl.deleteTexture(this.outputTexture),this.buffer&&this._webGl.deleteBuffer(this.buffer),this.framebuffer&&this._webGl.deleteFramebuffer(this.framebuffer),this.vertShader&&this._webGl.deleteShader(this.vertShader),this.fragShader&&this._webGl.deleteShader(this.fragShader),this.program&&this._webGl.deleteProgram(this.program);for(var n=Object.keys(this.textureCache),r=0;r<n.length;r++){var i=n[r];this._webGl.deleteTexture(this.textureCache[i])}if(this.subKernelOutputTextures)for(var s=0;s<this.subKernelOutputTextures.length;s++)this._webGl.deleteTexture(this.subKernelOutputTextures[s]);if(t){var o=d.indexOf(this._canvas);o>=0&&(d[o]=null,m[o]=null)}delete this._webGl}}]),e}(u)},{"../../core/texture":30,"../../core/utils":32,"../kernel-base":8,"./kernel-string":20,"./shader-frag":23,"./shader-vert":24}],22:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("../runner-base"),u=t("./kernel"),h=t("./function-builder");e.exports=function(t){function e(t){r(this,e);var n=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,new h,t));return n.Kernel=u,n.kernel=null,n}return s(e,t),a(e,[{key:"getMode",value:function(){return"gpu"}}]),e}(o)},{"../runner-base":10,"./function-builder":18,"./kernel":21}],23:[function(t,e,n){e.exports="__HEADER__;\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nconst float LOOP_MAX = __LOOP_MAX__;\n\n__CONSTANTS__;\n\nvarying vec2 vTexCoord;\n\nvec4 round(vec4 x) {\n  return floor(x + 0.5);\n}\n\nfloat round(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\nfloat integerMod(float x, float y) {\n  float res = floor(mod(x, y));\n  return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);\n}\n\nint integerMod(int x, int y) {\n  return x - (y * int(x / y));\n}\n\n__DIVIDE_WITH_INTEGER_CHECK__;\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\nfloat decode32(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\nvec4 encode32(float f) {\n  float F = abs(f);\n  float sign = f < 0.0 ? 1.0 : 0.0;\n  float exponent = floor(log2(F));\n  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\nfloat decode(vec4 rgba, int x, int bitRatio) {\n  if (bitRatio == 1) {\n    return decode32(rgba);\n  }\n  __DECODE32_ENDIANNESS__;\n  int channel = integerMod(x, bitRatio);\n  if (bitRatio == 4) {\n    if (channel == 0) return rgba.r * 255.0;\n    if (channel == 1) return rgba.g * 255.0;\n    if (channel == 2) return rgba.b * 255.0;\n    if (channel == 3) return rgba.a * 255.0;\n  }\n  else {\n    if (channel == 0) return rgba.r * 255.0 + rgba.g * 65280.0;\n    if (channel == 1) return rgba.b * 255.0 + rgba.a * 65280.0;\n  }\n}\n\nint index;\nivec3 threadId;\n\nivec3 indexTo3D(int idx, ivec3 texDim) {\n  int z = int(idx / (texDim.x * texDim.y));\n  idx -= z * int(texDim.x * texDim.y);\n  int y = int(idx / texDim.x);\n  int x = int(integerMod(idx, texDim.x));\n  return ivec3(x, y, z);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio,  int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  vec4 texel = texture2D(tex, st / vec2(texSize));\n  __GET_RESULT__;\n  \n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {\n  ivec3 xyz = ivec3(x, y, z);\n  __GET_WRAPAROUND__;\n  int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);\n  __GET_TEXTURE_CHANNEL__;\n  int w = texSize.x;\n  vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;\n  __GET_TEXTURE_INDEX__;\n  return texture2D(tex, st / vec2(texSize));\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int y, int x) {\n  return get(tex, texSize, texDim, bitRatio, int(0), y, x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int y, int x) {\n  return getImage2D(tex, texSize, texDim, int(0), y, x);\n}\n\nfloat get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int x) {\n  return get(tex, texSize, texDim, bitRatio, int(0), int(0), x);\n}\n\nvec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int x) {\n  return getImage2D(tex, texSize, texDim, int(0), int(0), x);\n}\n\n\nvec4 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\nvoid color(sampler2D image) {\n  actualColor = texture2D(image, vTexCoord);\n}\n\n__MAIN_PARAMS__;\n__MAIN_CONSTANTS__;\n__KERNEL__;\n\nvoid main(void) {\n  index = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;\n  __MAIN_RESULT__;\n}";
+},{}],24:[function(t,e,n){e.exports="precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nattribute vec2 aPos;\nattribute vec2 aTexCoord;\n\nvarying 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}"},{}],25:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("./kernel"),u=t("../../core/utils");e.exports=function(t){function e(){return r(this,e),i(this,(e.__proto__||Object.getPrototypeOf(e)).apply(this,arguments))}return s(e,t),a(e,[{key:"validateOptions",value:function(){this.texSize=u.dimToTexSize({floatTextures:this.floatTextures,floatOutput:this.floatOutput},this.output,!0)}}]),e}(o)},{"../../core/utils":32,"./kernel":21}],26:[function(t,e,n){var r=t("./utils");e.exports=function(t,e){var n=e.toString();return new Function("return function "+t+" ("+r.getParamNamesFromString(n).join(", ")+") {"+r.getFunctionBodyFromString(n)+"}")()}},{"./utils":32}],27:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}();t("./utils-core");e.exports=function(){function t(){r(this,t)}return i(t,null,[{key:"validateKernelObj",value:function(t){if(null===t)throw"KernelObj being validated is NULL";if("string"==typeof t){try{t=JSON.parse(t)}catch(e){throw console.error(e),"Failed to convert KernelObj from JSON string"}if(null===t)throw"Invalid (NULL) KernelObj JSON string representation"}if(t.isKernelObj!==!0)throw"Failed missing isKernelObj flag check";return t}},{key:"loadKernelObj",value:function(t,e){t=validateKernelObj(t)}}]),t}()},{"./utils-core":31}],28:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a=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}}(),o=t("./utils"),u=t("../backend/web-gl/runner"),h=t("../backend/web-gl2/runner"),c=t("../backend/cpu/runner"),l=t("../backend/web-gl/validator-kernel"),p=t("../backend/web-gl2/validator-kernel"),f=t("./gpu-core"),d=function(t){function e(t){r(this,e);var n=i(this,(e.__proto__||Object.getPrototypeOf(e)).call(this,t));t=t||{},n._canvas=t.canvas||null,n._webGl=t.webGl||null;var s=t.mode,a=void 0;if(o.isWebGlSupported())if(n._webGl)if("undefined"!=typeof WebGL2RenderingContext&&n._webGl.constructor===WebGL2RenderingContext)a="webgl2";else{if("undefined"==typeof WebGLRenderingContext||n._webGl.constructor!==WebGLRenderingContext)throw new Error("unknown WebGL Context");a="webgl"}else a=s||"gpu";else{if(s&&"cpu"!==s)throw new Error('A requested mode of "'+s+'" and is not supported');console.warn("Warning: gpu not supported, falling back to cpu support"),a="cpu"}n.kernels=[];var f={canvas:n._canvas,webGl:n._webGl};switch(a){case"cpu":n._runner=new c(f);break;case"gpu":var d=n.getGPURunner();n._runner=new d(f);break;case"webgl2":n._runner=new h(f);break;case"webgl":n._runner=new u(f);break;case"webgl2-validator":n._runner=new h(f),n._runner.Kernel=p;break;case"webgl-validator":n._runner=new u(f),n._runner.Kernel=l;break;default:throw new Error('"'+s+'" mode is not defined')}return n}return s(e,t),a(e,[{key:"createKernel",value:function(t,e){if("undefined"==typeof t)throw"Missing fn parameter";if(!o.isFunction(t)&&"string"!=typeof t)throw"fn parameter not a function";var n=Object.assign({webGl:this._webGl,canvas:this._canvas},e||{}),r=this._runner.buildKernel(t,n);return this._canvas||(this._canvas=r.getCanvas()),this._runner.canvas||(this._runner.canvas=r.getCanvas()),this.kernels.push(r),r}},{key:"createKernelMap",value:function(){var t=void 0,e=void 0;"function"==typeof arguments[arguments.length-2]?(t=arguments[arguments.length-2],e=arguments[arguments.length-1]):t=arguments[arguments.length-1],o.isWebGlDrawBuffersSupported()||(this._runner=new c(e));var n=this.createKernel(t,e);if(Array.isArray(arguments[0]))for(var r=arguments[0],i=0;i<r.length;i++)n.addSubKernel(r[i]);else{var s=arguments[0];for(var a in s)s.hasOwnProperty(a)&&n.addSubKernelProperty(a,s[a])}return n}},{key:"combineKernels",value:function(){var t=arguments[arguments.length-2],e=arguments[arguments.length-1];if("cpu"===this.getMode())return e;for(var n=arguments[0].getCanvas(),r=arguments[0].getWebGl(),i=0;i<arguments.length-1;i++)arguments[i].setCanvas(n).setWebGl(r).setOutputToTexture(!0);return function(){e.apply(null,arguments);var n=t.texSize,r=t.getWebGl(),i=t.threadDim,s=void 0;if(t.floatOutput){var a=n[0],u=Math.ceil(n[1]/4);s=new Float32Array(a*u*4),r.readPixels(0,0,a,u,r.RGBA,r.FLOAT,s)}else{var h=new Uint8Array(n[0]*n[1]*4);r.readPixels(0,0,n[0],n[1],r.RGBA,r.UNSIGNED_BYTE,h),s=new Float32Array(h.buffer)}if(s=s.subarray(0,i[0]*i[1]*i[2]),1===t.output.length)return s;if(2===t.output.length)return o.splitArray(s,t.output[0]);if(3===t.output.length){var c=o.splitArray(s,t.output[0]*t.output[1]);return c.map(function(e){return o.splitArray(e,t.output[0])})}}}},{key:"getGPURunner",value:function(){return"undefined"!=typeof WebGL2RenderingContext&&o.isWebGl2Supported()?h:"undefined"!=typeof WebGLRenderingContext?u:void 0}},{key:"addFunction",value:function(t,e){return this._runner.functionBuilder.addFunction(null,t,e),this}},{key:"addNativeFunction",value:function(t,e){return this._runner.functionBuilder.addNativeFunction(t,e),this}},{key:"getMode",value:function(){return this._runner.getMode()}},{key:"isWebGlSupported",value:function(){return o.isWebGlSupported()}},{key:"hasIntegerDivisionAccuracyBug",value:function(){return o.hasIntegerDivisionAccuracyBug()}},{key:"getCanvas",value:function(){return this._canvas}},{key:"getWebGl",value:function(){return this._webGl}},{key:"destroy",value:function(){var t=this;setTimeout(function(){for(var e=t.kernels,n=!t._webGl&&e.length&&e[0]._webGl,r=0;r<t.kernels.length;r++)t.kernels[r].destroy(!0);if(n){n.OES_texture_float=null,n.OES_texture_float_linear=null,n.OES_element_index_uint=null;var i=n.getExtension("WEBGL_lose_context");i&&i.loseContext()}},0)}}]),e}(f);Object.assign(d,f),e.exports=d},{"../backend/cpu/runner":5,"../backend/web-gl/runner":22,"../backend/web-gl/validator-kernel":25,"../backend/web-gl2/runner":14,"../backend/web-gl2/validator-kernel":17,"./gpu-core":27,"./utils":32}],29:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}e.exports=function i(t,e){if(r(this,i),this.value=t,Array.isArray(e)){this.size=[];for(var n=0;n<e.length;n++)this.size[n]=e[n];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]}},{}],30:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}();e.exports=function(){function t(e,n,i,s,a){var o=arguments.length>5&&void 0!==arguments[5]?arguments[5]:"NumberTexture";r(this,t),this.texture=e,this.size=n,this.dimensions=i,this.output=s,this.webGl=a,this.kernel=null,this.type=o}return i(t,[{key:"toArray",value:function(t){if(!t)throw new Error("You need to pass the GPU object for toArray to work.");return this.kernel?this.kernel(this):(this.kernel=t.createKernel(function(t){return t[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)}}]),t}()},{}],31:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var i=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}}(),s=function(){function t(){r(this,t)}return i(t,null,[{key:"isCanvas",value:function(t){return null!==t&&(t.nodeName&&t.getContext&&"CANVAS"===t.nodeName.toUpperCase()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas)}},{key:"isCanvasSupported",value:function(){return a}},{key:"initCanvas",value:function(){if(!a)return null;var t="undefined"!=typeof document?document.createElement("canvas"):new OffscreenCanvas(0,0);return t.width=2,t.height=2,t}},{key:"isWebGl",value:function(t){return t&&"function"==typeof t.getExtension}},{key:"isWebGl2",value:function(t){return t&&"undefined"!=typeof WebGL2RenderingContext&&t instanceof WebGL2RenderingContext}},{key:"isWebGlSupported",value:function(){return h}},{key:"isWebGl2Supported",value:function(){return c}},{key:"isWebGlDrawBuffersSupported",value:function(){return l}},{key:"initWebGlDefaultOptions",value:function(){return{alpha:!1,depth:!1,antialias:!1}}},{key:"initWebGl",value:function(e){if(("undefined"!=typeof a||null===e)&&!a)return null;if(!t.isCanvas(e))throw new Error("Invalid canvas object - "+e);var n=null,r=t.initWebGlDefaultOptions();try{n=e.getContext("experimental-webgl",r)}catch(i){}return null===n&&(n=e.getContext("webgl2",r)||e.getContext("webgl",r)),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}},{key:"initWebGl2",value:function(e){if(("undefined"!=typeof a||null===e)&&!a)return null;if(!t.isCanvas(e))throw new Error("Invalid canvas object - "+e);return e.getContext("webgl2",t.initWebGlDefaultOptions())}},{key:"checkOutput",value:function(t){if(!t||!Array.isArray(t))throw new Error("kernel.output not an array");for(var e=0;e<t.length;e++)if(isNaN(t[e])||t[e]<1)throw new Error("kernel.output["+e+"] incorrectly defined as `"+t[e]+"`, needs to be numeric, and greater than 0")}}]),t}(),a="undefined"!=typeof document?s.isCanvas(document.createElement("canvas")):"undefined"!=typeof OffscreenCanvas,o=s.initWebGl(s.initCanvas()),u=s.initWebGl2(s.initCanvas()),h=s.isWebGl(o),c=s.isWebGl2(u),l=h&&Boolean(o.getExtension("WEBGL_draw_buffers"));h?(s.OES_texture_float=o.OES_texture_float,s.OES_texture_float_linear=o.OES_texture_float_linear,s.OES_element_index_uint=o.OES_element_index_uint):(s.OES_texture_float=!1,s.OES_texture_float_linear=!1,s.OES_element_index_uint=!1),e.exports=s},{}],32:[function(t,e,n){function r(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(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 s(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 a="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},o=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}}(),u=t("./utils-core"),h=t("./input"),c=t("./texture"),l=/function ([^(]*)/,p=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,f=/([^\s,]+)/g,d=function(){var t=new ArrayBuffer(4),e=new Uint32Array(t),n=new Uint8Array(t);if(e[0]=3735928559,239===n[0])return"LE";if(222===n[0])return"BE";throw new Error("unknown endianness")}(),m=null,g=null,y=function(){try{return new Function("let i = 1; const j = 1;")(),!0}catch(t){return!1}}(),x=null,v=function(e){function n(){return r(this,n),i(this,(n.__proto__||Object.getPrototypeOf(n)).apply(this,arguments))}return s(n,e),o(n,null,[{key:"systemEndianness",value:function(){return d}},{key:"isFunction",value:function(t){return"function"==typeof t}},{key:"isFunctionString",value:function(t){return null!==t&&"function"===t.toString().slice(0,"function".length).toLowerCase()}},{key:"getFunctionNameFromString",value:function(t){return l.exec(t)[1]}},{key:"getFunctionBodyFromString",value:function(t){return t.substring(t.indexOf("{")+1,t.lastIndexOf("}"))}},{key:"getParamNamesFromString",value:function(t){var e=t.toString().replace(p,""),n=e.slice(e.indexOf("(")+1,e.indexOf(")")).match(f);return null===n&&(n=[]),n}},{key:"clone",value:function(t){if(null===t||"object"!==("undefined"==typeof t?"undefined":a(t))||t.hasOwnProperty("isActiveClone"))return t;var e=t.constructor();for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(t.isActiveClone=null,e[r]=n.clone(t[r]),delete t.isActiveClone);return e}},{key:"newPromise",value:function(t){var e=Promise||small_promise;if(null===e)throw TypeError("Browser is missing Promise implementation. Consider adding small_promise.js polyfill");return new e(t)}},{key:"functionBinder",value:function(t,e){return t.bind?t.bind(e):function(){var n=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);return t.apply(e,n)}}},{key:"isArray",value:function(t){return!isNaN(t.length)}},{key:"getArgumentType",value:function(t){return n.isArray(t)?"IMG"===t[0].nodeName?"HTMLImageArray":"Array":"number"==typeof t?Number.isInteger(t)?"Integer":"Float":t instanceof c?t.type:t instanceof h?"Input":"IMG"===t.nodeName?"HTMLImage":"Unknown"}},{key:"isFloatReadPixelsSupported",value:function(){if(null!==m)return m;var e=t("../index"),n=new e({mode:"webgl-validator"}),r=n.createKernel(function(){return 1},{output:[2],floatTextures:!0,floatOutput:!0,floatOutputForce:!0})();return m=1===r[0],n.destroy(),m}},{key:"isFloatReadPixelsSupportedWebGL2",value:function(){if(null!==g)return g;var e=t("../index"),n=new e({mode:"webgl2-validator"}),r=n.createKernel(function(){return 1},{output:[2],floatTextures:!0,floatOutput:!0,floatOutputForce:!0})();return g=1===r[0],n.destroy(),g}},{key:"hasIntegerDivisionAccuracyBug",value:function(){if(null!==x)return x;var e=t("../index"),n=new e({mode:"webgl-validator"}),r=n.createKernel(function(t,e){return t[this.thread.x]/e[this.thread.x]},{output:[1]})([6,6030401],[3,3991]);return x=2!==r[0]||1511!==r[1],n.destroy(),x}},{key:"isMixedIdentifiersSupported",value:function(){return y}},{key:"dimToTexSize",value:function(t,e,n){for(var r=e[0],i=e[0],s=e[1],a=1;a<e.length;a++)r*=e[a];if(!t.floatTextures||n&&!t.floatOutput||(i=r=Math.ceil(r/4)),s>1&&i*s===r)return[i,s];for(var o=Math.sqrt(r),u=Math.ceil(o),h=Math.floor(o);u*h>r;)u--,h=Math.ceil(r/u);return i=h,s=Math.ceil(r/i),[i,s]}},{key:"getDimensions",value:function(t,e){var r=void 0;if(n.isArray(t)){for(var i=[],s=t;n.isArray(s);)i.push(s.length),s=s[0];r=i.reverse()}else if(t instanceof c)r=t.output;else{if(!(t instanceof h))throw"Unknown dimensions of "+t;r=t.size}if(e)for(r=n.clone(r);r.length<3;)r.push(1);return new Int32Array(r)}},{key:"pad",value:function(t,e){function n(t){return Array.apply(null,new Array(t)).map(Number.prototype.valueOf,0)}for(var r=t.length+2*e,i=t.map(function(t){return[].concat(n(e),t,n(e))}),s=0;s<e;s++)i=[].concat([n(r)],i,[n(r)]);return i}},{key:"flatten2dArrayTo",value:function(t,e){for(var n=0,r=0;r<t.length;r++)e.set(t[r],n),n+=t[r].length}},{key:"flatten3dArrayTo",value:function(t,e){for(var n=0,r=0;r<t.length;r++)for(var i=0;i<t[r].length;i++)e.set(t[r][i],n),n+=t[r][i].length}},{key:"flattenTo",value:function(t,e){n.isArray(t[0])?n.isArray(t[0][0])?n.flatten3dArrayTo(t,e):n.flatten2dArrayTo(t,e):e.set(t)}},{key:"splitArray",value:function(t,e){for(var n=[],r=0;r<t.length;r+=e)n.push(new t.constructor(t.buffer,4*r+t.byteOffset,e));return n}},{key:"getAstString",value:function(t,e){var n=Array.isArray(t)?t:t.split(/\r?\n/g),r=e.loc.start,i=e.loc.end,s=[];s.push(n[r.line-1].slice(r.column));for(var a=r.line;a<i.line-1;a++)s.push(n[a]);return s.push(n[i.line-1].slice(0,i.column)),s.join("\n")}},{key:"allPropertiesOf",value:function(t){var e=[];do e.push.apply(e,Object.getOwnPropertyNames(t));while(t=Object.getPrototypeOf(t));return e}}]),n}(u);Object.assign(v,u),e.exports=v},{"../index":33,"./input":29,"./texture":30,"./utils-core":31}],33:[function(t,e,n){var r=t("./core/gpu"),i=t("./core/alias"),s=t("./core/utils"),a=t("./core/input"),o=t("./core/texture"),u=t("./backend/cpu/function-builder"),h=t("./backend/cpu/function-node"),c=t("./backend/cpu/kernel"),l=t("./backend/cpu/runner"),p=t("./backend/web-gl/function-builder"),f=t("./backend/web-gl/function-node"),d=t("./backend/web-gl/kernel"),m=t("./backend/web-gl/runner"),g=t("./backend/web-gl2/function-builder"),y=t("./backend/web-gl2/function-node"),x=t("./backend/web-gl2/kernel"),v=t("./backend/web-gl2/runner");r.alias=i,r.utils=s,r.Texture=o,r.Input=a,r.input=function(t,e){return new a(t,e)},r.CPUFunctionBuilder=u,r.CPUFunctionNode=h,r.CPUKernel=c,r.CPURunner=l,r.WebGLFunctionBuilder=p,r.WebGLFunctionNode=f,r.WebGLKernel=d,r.WebGLRunner=m,r.WebGL2FunctionBuilder=g,r.WebGL2FunctionNode=y,r.WebGL2Kernel=x,r.WebGL2Runner=v,"undefined"!=typeof e&&(e.exports=r),"undefined"!=typeof window&&(window.GPU=r),"undefined"!=typeof self&&(self.GPU=r)},{"./backend/cpu/function-builder":1,"./backend/cpu/function-node":2,"./backend/cpu/kernel":4,"./backend/cpu/runner":5,"./backend/web-gl/function-builder":18,"./backend/web-gl/function-node":19,"./backend/web-gl/kernel":21,"./backend/web-gl/runner":22,"./backend/web-gl2/function-builder":11,"./backend/web-gl2/function-node":12,"./backend/web-gl2/kernel":13,"./backend/web-gl2/runner":14,"./core/alias":26,"./core/gpu":28,"./core/input":29,"./core/texture":30,"./core/utils":32}],34:[function(t,e,n){!function(t,r){"object"==typeof n&&"undefined"!=typeof e?r(n):"function"==typeof define&&define.amd?define(["exports"],r):r(t.acorn={})}(this,function(t){function e(t,e){for(var n=65536,r=0;r<e.length;r+=2){if(n+=e[r],n>t)return!1;if(n+=e[r+1],n>=t)return!0}}function n(t,n){return t<65?36===t:t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&G.test(String.fromCharCode(t)):n!==!1&&e(t,j)))}function r(t,n){return t<48?36===t:t<58||!(t<65)&&(t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&M.test(String.fromCharCode(t)):n!==!1&&(e(t,j)||e(t,B)))))}function i(t,e){return new V(t,{beforeExpr:!0,binop:e})}function s(t,e){return void 0===e&&(e={}),e.keyword=t,K[t]=new V(t,e)}function a(t,e){return 10===t||13===t||!e&&(8232===t||8233===t)}function o(t,e){return Z.call(t,e)}function u(t,e){for(var n=1,r=0;;){Y.lastIndex=r;var i=Y.exec(t);if(!(i&&i.index<e))return new et(n,e-r);++n,r=i.index+i[0].length}}function h(t){var e={};for(var n in rt)e[n]=t&&o(t,n)?t[n]:rt[n];if(e.ecmaVersion>=2015&&(e.ecmaVersion-=2009),null==e.allowReserved&&(e.allowReserved=e.ecmaVersion<5),tt(e.onToken)){var r=e.onToken;e.onToken=function(t){return r.push(t)}}return tt(e.onComment)&&(e.onComment=c(e,e.onComment)),e}function c(t,e){return function(n,r,i,s,a,o){var u={type:n?"Block":"Line",value:r,start:i,end:s};t.locations&&(u.loc=new nt(this,a,o)),t.ranges&&(u.range=[i,s]),e.push(u)}}function l(t){return new RegExp("^(?:"+t.replace(/ /g,"|")+")$")}function p(){this.shorthandAssign=this.trailingComma=this.parenthesizedAssign=this.parenthesizedBind=this.doubleProto=-1}function f(t,e,n,r){return t.type=e,t.end=n,this.options.locations&&(t.loc.end=r),this.options.ranges&&(t.range[1]=n),t}function d(t){return t<=65535?String.fromCharCode(t):(t-=65536,String.fromCharCode((t>>10)+55296,(1023&t)+56320))}function m(t){return 36===t||t>=40&&t<=43||46===t||63===t||t>=91&&t<=94||t>=123&&t<=125}function g(t){return n(t,!0)||36===t||95===t}function y(t){return r(t,!0)||36===t||95===t||8204===t||8205===t}function x(t){return t>=65&&t<=90||t>=97&&t<=122}function v(t){return t>=0&&t<=1114111}function b(t){return 100===t||68===t||115===t||83===t||119===t||87===t}function _(t){return x(t)||95===t}function E(t){return _(t)||T(t)}function T(t){return t>=48&&t<=57}function S(t){return t>=48&&t<=57||t>=65&&t<=70||t>=97&&t<=102}function k(t){return t>=65&&t<=70?10+(t-65):t>=97&&t<=102?10+(t-97):t-48}function A(t){return t>=48&&t<=55}function w(t){return t<=65535?String.fromCharCode(t):(t-=65536,String.fromCharCode((t>>10)+55296,(1023&t)+56320))}function R(t,e){return new st(e,t).parse()}function O(t,e,n){var r=new st(n,t,e);return r.nextToken(),r.parseExpression()}function D(t,e){return new st(e,t)}function C(e,n,r){t.parse_dammit=e,t.LooseParser=n,t.pluginsLoose=r}var I={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"},P="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",N={5:P,6:P+" const class extends export import super"},L=/^in(stanceof)?$/,U="ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࢠ-ࢴࢶ-ࢽऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿯ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞹꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ",F="‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛࣓-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳷-᳹᷀-᷹᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿",G=new RegExp("["+U+"]"),M=new RegExp("["+U+F+"]");U=F=null;var j=[0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,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,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,190,52,76,44,33,24,27,35,30,0,12,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,26,230,43,117,63,32,0,257,0,11,39,8,0,22,0,12,39,3,3,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,68,12,0,67,12,65,1,31,6129,15,754,9486,286,82,395,2309,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,15,7472,3104,541],B=[509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,280,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,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],V=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},X={beforeExpr:!0},z={startsExpr:!0},K={},W={num:new V("num",z),regexp:new V("regexp",z),string:new V("string",z),name:new V("name",z),eof:new V("eof"),bracketL:new V("[",{beforeExpr:!0,startsExpr:!0}),bracketR:new V("]"),braceL:new V("{",{beforeExpr:!0,startsExpr:!0}),braceR:new V("}"),parenL:new V("(",{beforeExpr:!0,startsExpr:!0}),parenR:new V(")"),comma:new V(",",X),semi:new V(";",X),colon:new V(":",X),dot:new V("."),question:new V("?",X),arrow:new V("=>",X),template:new V("template"),invalidTemplate:new V("invalidTemplate"),ellipsis:new V("...",X),backQuote:new V("`",z),dollarBraceL:new V("${",{beforeExpr:!0,startsExpr:!0}),eq:new V("=",{beforeExpr:!0,isAssign:!0}),assign:new V("_=",{beforeExpr:!0,isAssign:!0}),incDec:new V("++/--",{prefix:!0,postfix:!0,startsExpr:!0}),prefix:new V("!/~",{beforeExpr:!0,prefix:!0,startsExpr:!0}),logicalOR:i("||",1),logicalAND:i("&&",2),bitwiseOR:i("|",3),bitwiseXOR:i("^",4),bitwiseAND:i("&",5),equality:i("==/!=/===/!==",6),relational:i("</>/<=/>=",7),bitShift:i("<</>>/>>>",8),plusMin:new V("+/-",{beforeExpr:!0,binop:9,prefix:!0,startsExpr:!0}),modulo:i("%",10),star:i("*",10),slash:i("/",10),starstar:new V("**",{beforeExpr:!0}),_break:s("break"),_case:s("case",X),_catch:s("catch"),_continue:s("continue"),_debugger:s("debugger"),_default:s("default",X),_do:s("do",{isLoop:!0,beforeExpr:!0}),_else:s("else",X),_finally:s("finally"),_for:s("for",{isLoop:!0}),_function:s("function",z),_if:s("if"),_return:s("return",X),_switch:s("switch"),_throw:s("throw",X),_try:s("try"),_var:s("var"),_const:s("const"),_while:s("while",{isLoop:!0}),_with:s("with"),_new:s("new",{beforeExpr:!0,startsExpr:!0}),_this:s("this",z),_super:s("super",z),_class:s("class",z),_extends:s("extends",X),_export:s("export"),_import:s("import"),_null:s("null",z),_true:s("true",z),_false:s("false",z),_in:s("in",{beforeExpr:!0,binop:7}),_instanceof:s("instanceof",{beforeExpr:!0,binop:7}),_typeof:s("typeof",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_void:s("void",{beforeExpr:!0,prefix:!0,startsExpr:!0}),_delete:s("delete",{beforeExpr:!0,prefix:!0,startsExpr:!0})},H=/\r\n?|\n|\u2028|\u2029/,Y=new RegExp(H.source,"g"),q=/[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/,J=/(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g,Q=Object.prototype,Z=Q.hasOwnProperty,$=Q.toString,tt=Array.isArray||function(t){return"[object Array]"===$.call(t)},et=function(t,e){this.line=t,this.column=e};et.prototype.offset=function(t){return new et(this.line,this.column+t)};var nt=function(t,e,n){this.start=e,this.end=n,null!==t.sourceFile&&(this.source=t.sourceFile)},rt={ecmaVersion:7,sourceType:"script",onInsertedSemicolon:null,onTrailingComma:null,allowReserved:null,allowReturnOutsideFunction:!1,allowImportExportEverywhere:!1,allowAwaitOutsideFunction:!1,allowHashBang:!1,locations:!1,onToken:null,onComment:null,ranges:!1,program:null,sourceFile:null,directSourceFile:null,preserveParens:!1,plugins:{}},it={},st=function(t,e,n){this.options=t=h(t),this.sourceFile=t.sourceFile,this.keywords=l(N[t.ecmaVersion>=6?6:5]);var r="";if(!t.allowReserved){for(var i=t.ecmaVersion;!(r=I[i]);i--);"module"===t.sourceType&&(r+=" await")}this.reservedWords=l(r);var s=(r?r+" ":"")+I.strict;this.reservedWordsStrict=l(s),this.reservedWordsStrictBind=l(s+" "+I.strictBind),this.input=String(e),this.containsEsc=!1,this.loadPlugins(t.plugins),n?(this.pos=n,this.lineStart=this.input.lastIndexOf("\n",n-1)+1,this.curLine=this.input.slice(0,this.lineStart).split(H).length):(this.pos=this.lineStart=0,this.curLine=1),this.type=W.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(),this.regexpState=null};st.prototype.isKeyword=function(t){return this.keywords.test(t)},st.prototype.isReservedWord=function(t){return this.reservedWords.test(t)},st.prototype.extend=function(t,e){this[t]=e(this[t])},st.prototype.loadPlugins=function(t){var e=this;for(var n in t){var r=it[n];if(!r)throw new Error("Plugin '"+n+"' not found");r(e,t[n])}},st.prototype.parse=function(){var t=this.options.program||this.startNode();return this.nextToken(),this.parseTopLevel(t)};var at=st.prototype,ot=/^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;at.strictDirective=function(t){for(var e=this;;){J.lastIndex=t,t+=J.exec(e.input)[0].length;var n=ot.exec(e.input.slice(t));if(!n)return!1;if("use strict"===(n[1]||n[2]))return!0;t+=n[0].length}},at.eat=function(t){return this.type===t&&(this.next(),!0)},at.isContextual=function(t){return this.type===W.name&&this.value===t&&!this.containsEsc},at.eatContextual=function(t){return!!this.isContextual(t)&&(this.next(),!0)},at.expectContextual=function(t){this.eatContextual(t)||this.unexpected()},at.canInsertSemicolon=function(){return this.type===W.eof||this.type===W.braceR||H.test(this.input.slice(this.lastTokEnd,this.start))},at.insertSemicolon=function(){if(this.canInsertSemicolon())return this.options.onInsertedSemicolon&&this.options.onInsertedSemicolon(this.lastTokEnd,this.lastTokEndLoc),!0},at.semicolon=function(){this.eat(W.semi)||this.insertSemicolon()||this.unexpected()},at.afterTrailingComma=function(t,e){
+if(this.type===t)return this.options.onTrailingComma&&this.options.onTrailingComma(this.lastTokStart,this.lastTokStartLoc),e||this.next(),!0},at.expect=function(t){this.eat(t)||this.unexpected()},at.unexpected=function(t){this.raise(null!=t?t:this.start,"Unexpected token")},at.checkPatternErrors=function(t,e){if(t){t.trailingComma>-1&&this.raiseRecoverable(t.trailingComma,"Comma is not permitted after the rest element");var n=e?t.parenthesizedAssign:t.parenthesizedBind;n>-1&&this.raiseRecoverable(n,"Parenthesized pattern")}},at.checkExpressionErrors=function(t,e){if(!t)return!1;var n=t.shorthandAssign,r=t.doubleProto;return e?(n>=0&&this.raise(n,"Shorthand property assignments are valid only in destructuring patterns"),void(r>=0&&this.raiseRecoverable(r,"Redefinition of __proto__ property"))):n>=0||r>=0},at.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")},at.isSimpleAssignTarget=function(t){return"ParenthesizedExpression"===t.type?this.isSimpleAssignTarget(t.expression):"Identifier"===t.type||"MemberExpression"===t.type};var ut=st.prototype;ut.parseTopLevel=function(t){var e=this,n={};for(t.body||(t.body=[]);this.type!==W.eof;){var r=e.parseStatement(!0,!0,n);t.body.push(r)}return this.adaptDirectivePrologue(t.body),this.next(),this.options.ecmaVersion>=6&&(t.sourceType=this.options.sourceType),this.finishNode(t,"Program")};var ht={kind:"loop"},ct={kind:"switch"};ut.isLet=function(){if(this.options.ecmaVersion<6||!this.isContextual("let"))return!1;J.lastIndex=this.pos;var t=J.exec(this.input),e=this.pos+t[0].length,i=this.input.charCodeAt(e);if(91===i||123===i)return!0;if(n(i,!0)){for(var s=e+1;r(this.input.charCodeAt(s),!0);)++s;var a=this.input.slice(e,s);if(!L.test(a))return!0}return!1},ut.isAsyncFunction=function(){if(this.options.ecmaVersion<8||!this.isContextual("async"))return!1;J.lastIndex=this.pos;var t=J.exec(this.input),e=this.pos+t[0].length;return!(H.test(this.input.slice(this.pos,e))||"function"!==this.input.slice(e,e+8)||e+8!==this.input.length&&r(this.input.charAt(e+8)))},ut.parseStatement=function(t,e,n){var r,i=this.type,s=this.startNode();switch(this.isLet()&&(i=W._var,r="let"),i){case W._break:case W._continue:return this.parseBreakContinueStatement(s,i.keyword);case W._debugger:return this.parseDebuggerStatement(s);case W._do:return this.parseDoStatement(s);case W._for:return this.parseForStatement(s);case W._function:return!t&&this.options.ecmaVersion>=6&&this.unexpected(),this.parseFunctionStatement(s,!1);case W._class:return t||this.unexpected(),this.parseClass(s,!0);case W._if:return this.parseIfStatement(s);case W._return:return this.parseReturnStatement(s);case W._switch:return this.parseSwitchStatement(s);case W._throw:return this.parseThrowStatement(s);case W._try:return this.parseTryStatement(s);case W._const:case W._var:return r=r||this.value,t||"var"===r||this.unexpected(),this.parseVarStatement(s,r);case W._while:return this.parseWhileStatement(s);case W._with:return this.parseWithStatement(s);case W.braceL:return this.parseBlock();case W.semi:return this.parseEmptyStatement(s);case W._export:case W._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'")),i===W._import?this.parseImport(s):this.parseExport(s,n);default:if(this.isAsyncFunction())return t||this.unexpected(),this.next(),this.parseFunctionStatement(s,!0);var a=this.value,o=this.parseExpression();return i===W.name&&"Identifier"===o.type&&this.eat(W.colon)?this.parseLabeledStatement(s,a,o):this.parseExpressionStatement(s,o)}},ut.parseBreakContinueStatement=function(t,e){var n=this,r="break"===e;this.next(),this.eat(W.semi)||this.insertSemicolon()?t.label=null:this.type!==W.name?this.unexpected():(t.label=this.parseIdent(),this.semicolon());for(var i=0;i<this.labels.length;++i){var s=n.labels[i];if(null==t.label||s.name===t.label.name){if(null!=s.kind&&(r||"loop"===s.kind))break;if(t.label&&r)break}}return i===this.labels.length&&this.raise(t.start,"Unsyntactic "+e),this.finishNode(t,r?"BreakStatement":"ContinueStatement")},ut.parseDebuggerStatement=function(t){return this.next(),this.semicolon(),this.finishNode(t,"DebuggerStatement")},ut.parseDoStatement=function(t){return this.next(),this.labels.push(ht),t.body=this.parseStatement(!1),this.labels.pop(),this.expect(W._while),t.test=this.parseParenExpression(),this.options.ecmaVersion>=6?this.eat(W.semi):this.semicolon(),this.finishNode(t,"DoWhileStatement")},ut.parseForStatement=function(t){this.next();var e=this.options.ecmaVersion>=9&&this.inAsync&&this.eatContextual("await")?this.lastTokStart:-1;if(this.labels.push(ht),this.enterLexicalScope(),this.expect(W.parenL),this.type===W.semi)return e>-1&&this.unexpected(e),this.parseFor(t,null);var n=this.isLet();if(this.type===W._var||this.type===W._const||n){var r=this.startNode(),i=n?"let":this.value;return this.next(),this.parseVar(r,!0,i),this.finishNode(r,"VariableDeclaration"),!(this.type===W._in||this.options.ecmaVersion>=6&&this.isContextual("of"))||1!==r.declarations.length||"var"!==i&&r.declarations[0].init?(e>-1&&this.unexpected(e),this.parseFor(t,r)):(this.options.ecmaVersion>=9&&(this.type===W._in?e>-1&&this.unexpected(e):t.await=e>-1),this.parseForIn(t,r))}var s=new p,a=this.parseExpression(!0,s);return this.type===W._in||this.options.ecmaVersion>=6&&this.isContextual("of")?(this.options.ecmaVersion>=9&&(this.type===W._in?e>-1&&this.unexpected(e):t.await=e>-1),this.toAssignable(a,!1,s),this.checkLVal(a),this.parseForIn(t,a)):(this.checkExpressionErrors(s,!0),e>-1&&this.unexpected(e),this.parseFor(t,a))},ut.parseFunctionStatement=function(t,e){return this.next(),this.parseFunction(t,!0,!1,e)},ut.parseIfStatement=function(t){return this.next(),t.test=this.parseParenExpression(),t.consequent=this.parseStatement(!this.strict&&this.type===W._function),t.alternate=this.eat(W._else)?this.parseStatement(!this.strict&&this.type===W._function):null,this.finishNode(t,"IfStatement")},ut.parseReturnStatement=function(t){return this.inFunction||this.options.allowReturnOutsideFunction||this.raise(this.start,"'return' outside of function"),this.next(),this.eat(W.semi)||this.insertSemicolon()?t.argument=null:(t.argument=this.parseExpression(),this.semicolon()),this.finishNode(t,"ReturnStatement")},ut.parseSwitchStatement=function(t){var e=this;this.next(),t.discriminant=this.parseParenExpression(),t.cases=[],this.expect(W.braceL),this.labels.push(ct),this.enterLexicalScope();for(var n,r=!1;this.type!==W.braceR;)if(e.type===W._case||e.type===W._default){var i=e.type===W._case;n&&e.finishNode(n,"SwitchCase"),t.cases.push(n=e.startNode()),n.consequent=[],e.next(),i?n.test=e.parseExpression():(r&&e.raiseRecoverable(e.lastTokStart,"Multiple default clauses"),r=!0,n.test=null),e.expect(W.colon)}else n||e.unexpected(),n.consequent.push(e.parseStatement(!0));return this.exitLexicalScope(),n&&this.finishNode(n,"SwitchCase"),this.next(),this.labels.pop(),this.finishNode(t,"SwitchStatement")},ut.parseThrowStatement=function(t){return this.next(),H.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 lt=[];ut.parseTryStatement=function(t){if(this.next(),t.block=this.parseBlock(),t.handler=null,this.type===W._catch){var e=this.startNode();this.next(),this.eat(W.parenL)?(e.param=this.parseBindingAtom(),this.enterLexicalScope(),this.checkLVal(e.param,"let"),this.expect(W.parenR)):(this.options.ecmaVersion<10&&this.unexpected(),e.param=null,this.enterLexicalScope()),e.body=this.parseBlock(!1),this.exitLexicalScope(),t.handler=this.finishNode(e,"CatchClause")}return t.finalizer=this.eat(W._finally)?this.parseBlock():null,t.handler||t.finalizer||this.raise(t.start,"Missing catch or finally clause"),this.finishNode(t,"TryStatement")},ut.parseVarStatement=function(t,e){return this.next(),this.parseVar(t,!1,e),this.semicolon(),this.finishNode(t,"VariableDeclaration")},ut.parseWhileStatement=function(t){return this.next(),t.test=this.parseParenExpression(),this.labels.push(ht),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"WhileStatement")},ut.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")},ut.parseEmptyStatement=function(t){return this.next(),this.finishNode(t,"EmptyStatement")},ut.parseLabeledStatement=function(t,e,n){for(var r=this,i=0,s=r.labels;i<s.length;i+=1){var a=s[i];a.name===e&&r.raise(n.start,"Label '"+e+"' is already declared")}for(var o=this.type.isLoop?"loop":this.type===W._switch?"switch":null,u=this.labels.length-1;u>=0;u--){var h=r.labels[u];if(h.statementStart!==t.start)break;h.statementStart=r.start,h.kind=o}return this.labels.push({name:e,kind:o,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=n,this.finishNode(t,"LabeledStatement")},ut.parseExpressionStatement=function(t,e){return t.expression=e,this.semicolon(),this.finishNode(t,"ExpressionStatement")},ut.parseBlock=function(t){var e=this;void 0===t&&(t=!0);var n=this.startNode();for(n.body=[],this.expect(W.braceL),t&&this.enterLexicalScope();!this.eat(W.braceR);){var r=e.parseStatement(!0);n.body.push(r)}return t&&this.exitLexicalScope(),this.finishNode(n,"BlockStatement")},ut.parseFor=function(t,e){return t.init=e,this.expect(W.semi),t.test=this.type===W.semi?null:this.parseExpression(),this.expect(W.semi),t.update=this.type===W.parenR?null:this.parseExpression(),this.expect(W.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,"ForStatement")},ut.parseForIn=function(t,e){var n=this.type===W._in?"ForInStatement":"ForOfStatement";return this.next(),"ForInStatement"===n&&("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"===n?this.parseExpression():this.parseMaybeAssign(),this.expect(W.parenR),this.exitLexicalScope(),t.body=this.parseStatement(!1),this.labels.pop(),this.finishNode(t,n)},ut.parseVar=function(t,e,n){var r=this;for(t.declarations=[],t.kind=n;;){var i=r.startNode();if(r.parseVarId(i,n),r.eat(W.eq)?i.init=r.parseMaybeAssign(e):"const"!==n||r.type===W._in||r.options.ecmaVersion>=6&&r.isContextual("of")?"Identifier"===i.id.type||e&&(r.type===W._in||r.isContextual("of"))?i.init=null:r.raise(r.lastTokEnd,"Complex binding patterns require an initialization value"):r.unexpected(),t.declarations.push(r.finishNode(i,"VariableDeclarator")),!r.eat(W.comma))break}return t},ut.parseVarId=function(t,e){t.id=this.parseBindingAtom(e),this.checkLVal(t.id,e,!1)},ut.parseFunction=function(t,e,n,r){this.initFunction(t),(this.options.ecmaVersion>=9||this.options.ecmaVersion>=6&&!r)&&(t.generator=this.eat(W.star)),this.options.ecmaVersion>=8&&(t.async=!!r),e&&(t.id="nullableID"===e&&this.type!==W.name?null:this.parseIdent(),t.id&&this.checkLVal(t.id,"var"));var i=this.inGenerator,s=this.inAsync,a=this.yieldPos,o=this.awaitPos,u=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===W.name?this.parseIdent():null),this.parseFunctionParams(t),this.parseFunctionBody(t,n),this.inGenerator=i,this.inAsync=s,this.yieldPos=a,this.awaitPos=o,this.inFunction=u,this.finishNode(t,e?"FunctionDeclaration":"FunctionExpression")},ut.parseFunctionParams=function(t){this.expect(W.parenL),t.params=this.parseBindingList(W.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams()},ut.parseClass=function(t,e){var n=this;this.next(),this.parseClassId(t,e),this.parseClassSuper(t);var r=this.startNode(),i=!1;for(r.body=[],this.expect(W.braceL);!this.eat(W.braceR);){var s=n.parseClassMember(r);s&&"MethodDefinition"===s.type&&"constructor"===s.kind&&(i&&n.raise(s.start,"Duplicate constructor in the same class"),i=!0)}return t.body=this.finishNode(r,"ClassBody"),this.finishNode(t,e?"ClassDeclaration":"ClassExpression")},ut.parseClassMember=function(t){var e=this;if(this.eat(W.semi))return null;var n=this.startNode(),r=function(t,r){void 0===r&&(r=!1);var i=e.start,s=e.startLoc;return!!e.eatContextual(t)&&(!(e.type===W.parenL||r&&e.canInsertSemicolon())||(n.key&&e.unexpected(),n.computed=!1,n.key=e.startNodeAt(i,s),n.key.name=t,e.finishNode(n.key,"Identifier"),!1))};n.kind="method",n["static"]=r("static");var i=this.eat(W.star),s=!1;i||(this.options.ecmaVersion>=8&&r("async",!0)?(s=!0,i=this.options.ecmaVersion>=9&&this.eat(W.star)):r("get")?n.kind="get":r("set")&&(n.kind="set")),n.key||this.parsePropertyName(n);var a=n.key;return n.computed||n["static"]||!("Identifier"===a.type&&"constructor"===a.name||"Literal"===a.type&&"constructor"===a.value)?n["static"]&&"Identifier"===a.type&&"prototype"===a.name&&this.raise(a.start,"Classes may not have a static property named prototype"):("method"!==n.kind&&this.raise(a.start,"Constructor can't have get/set modifier"),i&&this.raise(a.start,"Constructor can't be a generator"),s&&this.raise(a.start,"Constructor can't be an async method"),n.kind="constructor"),this.parseClassMethod(t,n,i,s),"get"===n.kind&&0!==n.value.params.length&&this.raiseRecoverable(n.value.start,"getter should have no params"),"set"===n.kind&&1!==n.value.params.length&&this.raiseRecoverable(n.value.start,"setter should have exactly one param"),"set"===n.kind&&"RestElement"===n.value.params[0].type&&this.raiseRecoverable(n.value.params[0].start,"Setter cannot use rest params"),n},ut.parseClassMethod=function(t,e,n,r){e.value=this.parseMethod(n,r),t.body.push(this.finishNode(e,"MethodDefinition"))},ut.parseClassId=function(t,e){t.id=this.type===W.name?this.parseIdent():e===!0?this.unexpected():null},ut.parseClassSuper=function(t){t.superClass=this.eat(W._extends)?this.parseExprSubscripts():null},ut.parseExport=function(t,e){var n=this;if(this.next(),this.eat(W.star))return this.expectContextual("from"),this.type!==W.string&&this.unexpected(),t.source=this.parseExprAtom(),this.semicolon(),this.finishNode(t,"ExportAllDeclaration");if(this.eat(W._default)){this.checkExport(e,"default",this.lastTokStart);var r;if(this.type===W._function||(r=this.isAsyncFunction())){var i=this.startNode();this.next(),r&&this.next(),t.declaration=this.parseFunction(i,"nullableID",!1,r)}else if(this.type===W._class){var s=this.startNode();t.declaration=this.parseClass(s,"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!==W.string&&this.unexpected(),t.source=this.parseExprAtom();else{for(var a=0,o=t.specifiers;a<o.length;a+=1){var u=o[a];n.checkUnreserved(u.local)}t.source=null}this.semicolon()}return this.finishNode(t,"ExportNamedDeclaration")},ut.checkExport=function(t,e,n){t&&(o(t,e)&&this.raiseRecoverable(n,"Duplicate export '"+e+"'"),t[e]=!0)},ut.checkPatternExport=function(t,e){var n=this,r=e.type;if("Identifier"===r)this.checkExport(t,e.name,e.start);else if("ObjectPattern"===r)for(var i=0,s=e.properties;i<s.length;i+=1){var a=s[i];n.checkPatternExport(t,a)}else if("ArrayPattern"===r)for(var o=0,u=e.elements;o<u.length;o+=1){var h=u[o];h&&n.checkPatternExport(t,h)}else"Property"===r?this.checkPatternExport(t,e.value):"AssignmentPattern"===r?this.checkPatternExport(t,e.left):"RestElement"===r?this.checkPatternExport(t,e.argument):"ParenthesizedExpression"===r&&this.checkPatternExport(t,e.expression)},ut.checkVariableExport=function(t,e){var n=this;if(t)for(var r=0,i=e;r<i.length;r+=1){var s=i[r];n.checkPatternExport(t,s.id)}},ut.shouldParseExportStatement=function(){return"var"===this.type.keyword||"const"===this.type.keyword||"class"===this.type.keyword||"function"===this.type.keyword||this.isLet()||this.isAsyncFunction()},ut.parseExportSpecifiers=function(t){var e=this,n=[],r=!0;for(this.expect(W.braceL);!this.eat(W.braceR);){if(r)r=!1;else if(e.expect(W.comma),e.afterTrailingComma(W.braceR))break;var i=e.startNode();i.local=e.parseIdent(!0),i.exported=e.eatContextual("as")?e.parseIdent(!0):i.local,e.checkExport(t,i.exported.name,i.exported.start),n.push(e.finishNode(i,"ExportSpecifier"))}return n},ut.parseImport=function(t){return this.next(),this.type===W.string?(t.specifiers=lt,t.source=this.parseExprAtom()):(t.specifiers=this.parseImportSpecifiers(),this.expectContextual("from"),t.source=this.type===W.string?this.parseExprAtom():this.unexpected()),this.semicolon(),this.finishNode(t,"ImportDeclaration")},ut.parseImportSpecifiers=function(){var t=this,e=[],n=!0;if(this.type===W.name){var r=this.startNode();if(r.local=this.parseIdent(),this.checkLVal(r.local,"let"),e.push(this.finishNode(r,"ImportDefaultSpecifier")),!this.eat(W.comma))return e}if(this.type===W.star){var i=this.startNode();return this.next(),this.expectContextual("as"),i.local=this.parseIdent(),this.checkLVal(i.local,"let"),e.push(this.finishNode(i,"ImportNamespaceSpecifier")),e}for(this.expect(W.braceL);!this.eat(W.braceR);){if(n)n=!1;else if(t.expect(W.comma),t.afterTrailingComma(W.braceR))break;var s=t.startNode();s.imported=t.parseIdent(!0),t.eatContextual("as")?s.local=t.parseIdent():(t.checkUnreserved(s.imported),s.local=s.imported),t.checkLVal(s.local,"let"),e.push(t.finishNode(s,"ImportSpecifier"))}return e},ut.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)},ut.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 pt=st.prototype;pt.toAssignable=function(t,e,n){var r=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",n&&this.checkPatternErrors(n,!0);for(var i=0,s=t.properties;i<s.length;i+=1){var a=s[i];r.toAssignable(a,e),"RestElement"!==a.type||"ArrayPattern"!==a.argument.type&&"ObjectPattern"!==a.argument.type||r.raise(a.argument.start,"Unexpected token")}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",n&&this.checkPatternErrors(n,!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 n&&this.checkPatternErrors(n,!0);return t},pt.toAssignableList=function(t,e){for(var n=this,r=t.length,i=0;i<r;i++){var s=t[i];s&&n.toAssignable(s,e)}if(r){var a=t[r-1];6===this.options.ecmaVersion&&e&&a&&"RestElement"===a.type&&"Identifier"!==a.argument.type&&this.unexpected(a.argument.start)}return t},pt.parseSpread=function(t){var e=this.startNode();return this.next(),e.argument=this.parseMaybeAssign(!1,t),this.finishNode(e,"SpreadElement")},pt.parseRestBinding=function(){var t=this.startNode();return this.next(),6===this.options.ecmaVersion&&this.type!==W.name&&this.unexpected(),t.argument=this.parseBindingAtom(),this.finishNode(t,"RestElement")},pt.parseBindingAtom=function(){if(this.options.ecmaVersion>=6)switch(this.type){case W.bracketL:var t=this.startNode();return this.next(),t.elements=this.parseBindingList(W.bracketR,!0,!0),this.finishNode(t,"ArrayPattern");case W.braceL:return this.parseObj(!0)}return this.parseIdent()},pt.parseBindingList=function(t,e,n){for(var r=this,i=[],s=!0;!this.eat(t);)if(s?s=!1:r.expect(W.comma),e&&r.type===W.comma)i.push(null);else{if(n&&r.afterTrailingComma(t))break;if(r.type===W.ellipsis){var a=r.parseRestBinding();r.parseBindingListItem(a),i.push(a),r.type===W.comma&&r.raise(r.start,"Comma is not permitted after the rest element"),r.expect(t);break}var o=r.parseMaybeDefault(r.start,r.startLoc);r.parseBindingListItem(o),i.push(o)}return i},pt.parseBindingListItem=function(t){return t},pt.parseMaybeDefault=function(t,e,n){if(n=n||this.parseBindingAtom(),this.options.ecmaVersion<6||!this.eat(W.eq))return n;var r=this.startNodeAt(t,e);return r.left=n,r.right=this.parseMaybeAssign(),this.finishNode(r,"AssignmentPattern")},pt.checkLVal=function(t,e,n){var r=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"),n&&(o(n,t.name)&&this.raiseRecoverable(t.start,"Argument name clash"),n[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 i=0,s=t.properties;i<s.length;i+=1){var a=s[i];r.checkLVal(a,e,n)}break;case"Property":this.checkLVal(t.value,e,n);break;case"ArrayPattern":for(var u=0,h=t.elements;u<h.length;u+=1){var c=h[u];c&&r.checkLVal(c,e,n)}break;case"AssignmentPattern":this.checkLVal(t.left,e,n);break;case"RestElement":this.checkLVal(t.argument,e,n);break;case"ParenthesizedExpression":this.checkLVal(t.expression,e,n);break;default:this.raise(t.start,(e?"Binding":"Assigning to")+" rvalue")}};var ft=st.prototype;ft.checkPropClash=function(t,e,n){if(!(this.options.ecmaVersion>=9&&"SpreadElement"===t.type||this.options.ecmaVersion>=6&&(t.computed||t.method||t.shorthand))){var r,i=t.key;switch(i.type){case"Identifier":r=i.name;break;case"Literal":r=String(i.value);break;default:return}var s=t.kind;if(this.options.ecmaVersion>=6)return void("__proto__"===r&&"init"===s&&(e.proto&&(n&&n.doubleProto<0?n.doubleProto=i.start:this.raiseRecoverable(i.start,"Redefinition of __proto__ property")),e.proto=!0));r="$"+r;var a=e[r];if(a){var o;o="init"===s?this.strict&&a.init||a.get||a.set:a.init||a[s],o&&this.raiseRecoverable(i.start,"Redefinition of property")}else a=e[r]={init:!1,get:!1,set:!1};a[s]=!0}},ft.parseExpression=function(t,e){var n=this,r=this.start,i=this.startLoc,s=this.parseMaybeAssign(t,e);if(this.type===W.comma){var a=this.startNodeAt(r,i);for(a.expressions=[s];this.eat(W.comma);)a.expressions.push(n.parseMaybeAssign(t,e));return this.finishNode(a,"SequenceExpression")}return s},ft.parseMaybeAssign=function(t,e,n){if(this.inGenerator&&this.isContextual("yield"))return this.parseYield();var r=!1,i=-1,s=-1;e?(i=e.parenthesizedAssign,s=e.trailingComma,e.parenthesizedAssign=e.trailingComma=-1):(e=new p,r=!0);var a=this.start,o=this.startLoc;this.type!==W.parenL&&this.type!==W.name||(this.potentialArrowAt=this.start);var u=this.parseMaybeConditional(t,e);if(n&&(u=n.call(this,u,a,o)),this.type.isAssign){var h=this.startNodeAt(a,o);return h.operator=this.value,h.left=this.type===W.eq?this.toAssignable(u,!1,e):u,r||p.call(e),e.shorthandAssign=-1,this.checkLVal(u),this.next(),h.right=this.parseMaybeAssign(t),this.finishNode(h,"AssignmentExpression")}return r&&this.checkExpressionErrors(e,!0),i>-1&&(e.parenthesizedAssign=i),s>-1&&(e.trailingComma=s),u},ft.parseMaybeConditional=function(t,e){var n=this.start,r=this.startLoc,i=this.parseExprOps(t,e);if(this.checkExpressionErrors(e))return i;if(this.eat(W.question)){var s=this.startNodeAt(n,r);return s.test=i,s.consequent=this.parseMaybeAssign(),this.expect(W.colon),s.alternate=this.parseMaybeAssign(t),this.finishNode(s,"ConditionalExpression")}return i},ft.parseExprOps=function(t,e){var n=this.start,r=this.startLoc,i=this.parseMaybeUnary(e,!1);return this.checkExpressionErrors(e)?i:i.start===n&&"ArrowFunctionExpression"===i.type?i:this.parseExprOp(i,n,r,-1,t)},ft.parseExprOp=function(t,e,n,r,i){var s=this.type.binop;if(null!=s&&(!i||this.type!==W._in)&&s>r){var a=this.type===W.logicalOR||this.type===W.logicalAND,o=this.value;this.next();var u=this.start,h=this.startLoc,c=this.parseExprOp(this.parseMaybeUnary(null,!1),u,h,s,i),l=this.buildBinary(e,n,t,c,o,a);return this.parseExprOp(l,e,n,r,i)}return t},ft.buildBinary=function(t,e,n,r,i,s){var a=this.startNodeAt(t,e);return a.left=n,a.operator=i,a.right=r,this.finishNode(a,s?"LogicalExpression":"BinaryExpression")},ft.parseMaybeUnary=function(t,e){var n,r=this,i=this.start,s=this.startLoc;if(this.isContextual("await")&&(this.inAsync||!this.inFunction&&this.options.allowAwaitOutsideFunction))n=this.parseAwait(),e=!0;else if(this.type.prefix){var a=this.startNode(),o=this.type===W.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,n=this.finishNode(a,o?"UpdateExpression":"UnaryExpression")}else{if(n=this.parseExprSubscripts(t),this.checkExpressionErrors(t))return n;for(;this.type.postfix&&!this.canInsertSemicolon();){var u=r.startNodeAt(i,s);u.operator=r.value,u.prefix=!1,u.argument=n,r.checkLVal(n),r.next(),n=r.finishNode(u,"UpdateExpression")}}return!e&&this.eat(W.starstar)?this.buildBinary(i,s,n,this.parseMaybeUnary(null,!1),"**",!1):n},ft.parseExprSubscripts=function(t){var e=this.start,n=this.startLoc,r=this.parseExprAtom(t),i="ArrowFunctionExpression"===r.type&&")"!==this.input.slice(this.lastTokStart,this.lastTokEnd);if(this.checkExpressionErrors(t)||i)return r;var s=this.parseSubscripts(r,e,n);return t&&"MemberExpression"===s.type&&(t.parenthesizedAssign>=s.start&&(t.parenthesizedAssign=-1),t.parenthesizedBind>=s.start&&(t.parenthesizedBind=-1)),s},ft.parseSubscripts=function(t,e,n,r){for(var i=this,s=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=i.eat(W.bracketL))||i.eat(W.dot)){var o=i.startNodeAt(e,n);o.object=t,o.property=a?i.parseExpression():i.parseIdent(!0),o.computed=!!a,a&&i.expect(W.bracketR),t=i.finishNode(o,"MemberExpression")}else if(!r&&i.eat(W.parenL)){var u=new p,h=i.yieldPos,c=i.awaitPos;i.yieldPos=0,i.awaitPos=0;var l=i.parseExprList(W.parenR,i.options.ecmaVersion>=8,!1,u);if(s&&!i.canInsertSemicolon()&&i.eat(W.arrow))return i.checkPatternErrors(u,!1),i.checkYieldAwaitInDefaultParams(),i.yieldPos=h,i.awaitPos=c,i.parseArrowExpression(i.startNodeAt(e,n),l,!0);i.checkExpressionErrors(u,!0),i.yieldPos=h||i.yieldPos,i.awaitPos=c||i.awaitPos;var f=i.startNodeAt(e,n);f.callee=t,f.arguments=l,t=i.finishNode(f,"CallExpression")}else{if(i.type!==W.backQuote)return t;var d=i.startNodeAt(e,n);d.tag=t,d.quasi=i.parseTemplate({isTagged:!0}),t=i.finishNode(d,"TaggedTemplateExpression")}},ft.parseExprAtom=function(t){var e,n=this.potentialArrowAt===this.start;switch(this.type){case W._super:return this.inFunction||this.raise(this.start,"'super' outside of function or class"),e=this.startNode(),this.next(),this.type!==W.dot&&this.type!==W.bracketL&&this.type!==W.parenL&&this.unexpected(),this.finishNode(e,"Super");case W._this:return e=this.startNode(),this.next(),this.finishNode(e,"ThisExpression");case W.name:var r=this.start,i=this.startLoc,s=this.containsEsc,a=this.parseIdent(this.type!==W.name);if(this.options.ecmaVersion>=8&&!s&&"async"===a.name&&!this.canInsertSemicolon()&&this.eat(W._function))return this.parseFunction(this.startNodeAt(r,i),!1,!1,!0);if(n&&!this.canInsertSemicolon()){if(this.eat(W.arrow))return this.parseArrowExpression(this.startNodeAt(r,i),[a],!1);if(this.options.ecmaVersion>=8&&"async"===a.name&&this.type===W.name&&!s)return a=this.parseIdent(),!this.canInsertSemicolon()&&this.eat(W.arrow)||this.unexpected(),this.parseArrowExpression(this.startNodeAt(r,i),[a],!0)}return a;case W.regexp:var o=this.value;return e=this.parseLiteral(o.value),e.regex={pattern:o.pattern,flags:o.flags},e;case W.num:case W.string:return this.parseLiteral(this.value);case W._null:case W._true:case W._false:return e=this.startNode(),e.value=this.type===W._null?null:this.type===W._true,e.raw=this.type.keyword,this.next(),this.finishNode(e,"Literal");case W.parenL:var u=this.start,h=this.parseParenAndDistinguishExpression(n);return t&&(t.parenthesizedAssign<0&&!this.isSimpleAssignTarget(h)&&(t.parenthesizedAssign=u),t.parenthesizedBind<0&&(t.parenthesizedBind=u)),h;case W.bracketL:return e=this.startNode(),this.next(),e.elements=this.parseExprList(W.bracketR,!0,!0,t),this.finishNode(e,"ArrayExpression");case W.braceL:return this.parseObj(!1,t);case W._function:return e=this.startNode(),this.next(),this.parseFunction(e,!1);case W._class:return this.parseClass(this.startNode(),!1);case W._new:return this.parseNew();case W.backQuote:return this.parseTemplate();default:this.unexpected()}},ft.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")},ft.parseParenExpression=function(){this.expect(W.parenL);var t=this.parseExpression();return this.expect(W.parenR),t},ft.parseParenAndDistinguishExpression=function(t){var e,n=this,r=this.start,i=this.startLoc,s=this.options.ecmaVersion>=8;if(this.options.ecmaVersion>=6){this.next();var a,o=this.start,u=this.startLoc,h=[],c=!0,l=!1,f=new p,d=this.yieldPos,m=this.awaitPos;for(this.yieldPos=0,this.awaitPos=0;this.type!==W.parenR;){if(c?c=!1:n.expect(W.comma),s&&n.afterTrailingComma(W.parenR,!0)){l=!0;break}if(n.type===W.ellipsis){a=n.start,h.push(n.parseParenItem(n.parseRestBinding())),n.type===W.comma&&n.raise(n.start,"Comma is not permitted after the rest element");break}h.push(n.parseMaybeAssign(!1,f,n.parseParenItem))}var g=this.start,y=this.startLoc;if(this.expect(W.parenR),t&&!this.canInsertSemicolon()&&this.eat(W.arrow))return this.checkPatternErrors(f,!1),this.checkYieldAwaitInDefaultParams(),this.yieldPos=d,this.awaitPos=m,this.parseParenArrowList(r,i,h);h.length&&!l||this.unexpected(this.lastTokStart),a&&this.unexpected(a),this.checkExpressionErrors(f,!0),this.yieldPos=d||this.yieldPos,this.awaitPos=m||this.awaitPos,h.length>1?(e=this.startNodeAt(o,u),e.expressions=h,this.finishNodeAt(e,"SequenceExpression",g,y)):e=h[0]}else e=this.parseParenExpression();if(this.options.preserveParens){var x=this.startNodeAt(r,i);return x.expression=e,this.finishNode(x,"ParenthesizedExpression");
+}return e},ft.parseParenItem=function(t){return t},ft.parseParenArrowList=function(t,e,n){return this.parseArrowExpression(this.startNodeAt(t,e),n)};var dt=[];ft.parseNew=function(){var t=this.startNode(),e=this.parseIdent(!0);if(this.options.ecmaVersion>=6&&this.eat(W.dot)){t.meta=e;var n=this.containsEsc;return t.property=this.parseIdent(!0),("target"!==t.property.name||n)&&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 r=this.start,i=this.startLoc;return t.callee=this.parseSubscripts(this.parseExprAtom(),r,i,!0),this.eat(W.parenL)?t.arguments=this.parseExprList(W.parenR,this.options.ecmaVersion>=8,!1):t.arguments=dt,this.finishNode(t,"NewExpression")},ft.parseTemplateElement=function(t){var e=t.isTagged,n=this.startNode();return this.type===W.invalidTemplate?(e||this.raiseRecoverable(this.start,"Bad escape sequence in untagged template literal"),n.value={raw:this.value,cooked:null}):n.value={raw:this.input.slice(this.start,this.end).replace(/\r\n?/g,"\n"),cooked:this.value},this.next(),n.tail=this.type===W.backQuote,this.finishNode(n,"TemplateElement")},ft.parseTemplate=function(t){var e=this;void 0===t&&(t={});var n=t.isTagged;void 0===n&&(n=!1);var r=this.startNode();this.next(),r.expressions=[];var i=this.parseTemplateElement({isTagged:n});for(r.quasis=[i];!i.tail;)e.expect(W.dollarBraceL),r.expressions.push(e.parseExpression()),e.expect(W.braceR),r.quasis.push(i=e.parseTemplateElement({isTagged:n}));return this.next(),this.finishNode(r,"TemplateLiteral")},ft.isAsyncProp=function(t){return!t.computed&&"Identifier"===t.key.type&&"async"===t.key.name&&(this.type===W.name||this.type===W.num||this.type===W.string||this.type===W.bracketL||this.type.keyword||this.options.ecmaVersion>=9&&this.type===W.star)&&!H.test(this.input.slice(this.lastTokEnd,this.start))},ft.parseObj=function(t,e){var n=this,r=this.startNode(),i=!0,s={};for(r.properties=[],this.next();!this.eat(W.braceR);){if(i)i=!1;else if(n.expect(W.comma),n.afterTrailingComma(W.braceR))break;var a=n.parseProperty(t,e);t||n.checkPropClash(a,s,e),r.properties.push(a)}return this.finishNode(r,t?"ObjectPattern":"ObjectExpression")},ft.parseProperty=function(t,e){var n,r,i,s,a=this.startNode();if(this.options.ecmaVersion>=9&&this.eat(W.ellipsis))return t?(a.argument=this.parseIdent(!1),this.type===W.comma&&this.raise(this.start,"Comma is not permitted after the rest element"),this.finishNode(a,"RestElement")):(this.type===W.parenL&&e&&(e.parenthesizedAssign<0&&(e.parenthesizedAssign=this.start),e.parenthesizedBind<0&&(e.parenthesizedBind=this.start)),a.argument=this.parseMaybeAssign(!1,e),this.type===W.comma&&e&&e.trailingComma<0&&(e.trailingComma=this.start),this.finishNode(a,"SpreadElement"));this.options.ecmaVersion>=6&&(a.method=!1,a.shorthand=!1,(t||e)&&(i=this.start,s=this.startLoc),t||(n=this.eat(W.star)));var o=this.containsEsc;return this.parsePropertyName(a),!t&&!o&&this.options.ecmaVersion>=8&&!n&&this.isAsyncProp(a)?(r=!0,n=this.options.ecmaVersion>=9&&this.eat(W.star),this.parsePropertyName(a,e)):r=!1,this.parsePropertyValue(a,t,n,r,i,s,e,o),this.finishNode(a,"Property")},ft.parsePropertyValue=function(t,e,n,r,i,s,a,o){if((n||r)&&this.type===W.colon&&this.unexpected(),this.eat(W.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===W.parenL)e&&this.unexpected(),t.kind="init",t.method=!0,t.value=this.parseMethod(n,r);else if(e||o||!(this.options.ecmaVersion>=5)||t.computed||"Identifier"!==t.key.type||"get"!==t.key.name&&"set"!==t.key.name||this.type===W.comma||this.type===W.braceR)this.options.ecmaVersion>=6&&!t.computed&&"Identifier"===t.key.type?(this.checkUnreserved(t.key),t.kind="init",e?t.value=this.parseMaybeDefault(i,s,t.key):this.type===W.eq&&a?(a.shorthandAssign<0&&(a.shorthandAssign=this.start),t.value=this.parseMaybeDefault(i,s,t.key)):t.value=t.key,t.shorthand=!0):this.unexpected();else{(n||r)&&this.unexpected(),t.kind=t.key.name,this.parsePropertyName(t),t.value=this.parseMethod(!1);var u="get"===t.kind?0:1;if(t.value.params.length!==u){var h=t.value.start;"get"===t.kind?this.raiseRecoverable(h,"getter should have no params"):this.raiseRecoverable(h,"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")}},ft.parsePropertyName=function(t){if(this.options.ecmaVersion>=6){if(this.eat(W.bracketL))return t.computed=!0,t.key=this.parseMaybeAssign(),this.expect(W.bracketR),t.key;t.computed=!1}return t.key=this.type===W.num||this.type===W.string?this.parseExprAtom():this.parseIdent(!0)},ft.initFunction=function(t){t.id=null,this.options.ecmaVersion>=6&&(t.generator=!1,t.expression=!1),this.options.ecmaVersion>=8&&(t.async=!1)},ft.parseMethod=function(t,e){var n=this.startNode(),r=this.inGenerator,i=this.inAsync,s=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.initFunction(n),this.options.ecmaVersion>=6&&(n.generator=t),this.options.ecmaVersion>=8&&(n.async=!!e),this.inGenerator=n.generator,this.inAsync=n.async,this.yieldPos=0,this.awaitPos=0,this.inFunction=!0,this.enterFunctionScope(),this.expect(W.parenL),n.params=this.parseBindingList(W.parenR,!1,this.options.ecmaVersion>=8),this.checkYieldAwaitInDefaultParams(),this.parseFunctionBody(n,!1),this.inGenerator=r,this.inAsync=i,this.yieldPos=s,this.awaitPos=a,this.inFunction=o,this.finishNode(n,"FunctionExpression")},ft.parseArrowExpression=function(t,e,n){var r=this.inGenerator,i=this.inAsync,s=this.yieldPos,a=this.awaitPos,o=this.inFunction;return this.enterFunctionScope(),this.initFunction(t),this.options.ecmaVersion>=8&&(t.async=!!n),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=r,this.inAsync=i,this.yieldPos=s,this.awaitPos=a,this.inFunction=o,this.finishNode(t,"ArrowFunctionExpression")},ft.parseFunctionBody=function(t,e){var n=e&&this.type!==W.braceL,r=this.strict,i=!1;if(n)t.body=this.parseMaybeAssign(),t.expression=!0,this.checkParams(t,!1);else{var s=this.options.ecmaVersion>=7&&!this.isSimpleParamList(t.params);r&&!s||(i=this.strictDirective(this.end),i&&s&&this.raiseRecoverable(t.start,"Illegal 'use strict' directive in function with non-simple parameter list"));var a=this.labels;this.labels=[],i&&(this.strict=!0),this.checkParams(t,!r&&!i&&!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=r},ft.isSimpleParamList=function(t){for(var e=0,n=t;e<n.length;e+=1){var r=n[e];if("Identifier"!==r.type)return!1}return!0},ft.checkParams=function(t,e){for(var n=this,r={},i=0,s=t.params;i<s.length;i+=1){var a=s[i];n.checkLVal(a,"var",e?null:r)}},ft.parseExprList=function(t,e,n,r){for(var i=this,s=[],a=!0;!this.eat(t);){if(a)a=!1;else if(i.expect(W.comma),e&&i.afterTrailingComma(t))break;var o=void 0;n&&i.type===W.comma?o=null:i.type===W.ellipsis?(o=i.parseSpread(r),r&&i.type===W.comma&&r.trailingComma<0&&(r.trailingComma=i.start)):o=i.parseMaybeAssign(!1,r),s.push(o)}return s},ft.checkUnreserved=function(t){var e=t.start,n=t.end,r=t.name;if(this.inGenerator&&"yield"===r&&this.raiseRecoverable(e,"Can not use 'yield' as identifier inside a generator"),this.inAsync&&"await"===r&&this.raiseRecoverable(e,"Can not use 'await' as identifier inside an async function"),this.isKeyword(r)&&this.raise(e,"Unexpected keyword '"+r+"'"),!(this.options.ecmaVersion<6&&this.input.slice(e,n).indexOf("\\")!==-1)){var i=this.strict?this.reservedWordsStrict:this.reservedWords;i.test(r)&&(this.inAsync||"await"!==r||this.raiseRecoverable(e,"Can not use keyword 'await' outside an async function"),this.raiseRecoverable(e,"The keyword '"+r+"' is reserved"))}},ft.parseIdent=function(t,e){var n=this.startNode();return t&&"never"===this.options.allowReserved&&(t=!1),this.type===W.name?n.name=this.value:this.type.keyword?(n.name=this.type.keyword,"class"!==n.name&&"function"!==n.name||this.lastTokEnd===this.lastTokStart+1&&46===this.input.charCodeAt(this.lastTokStart)||this.context.pop()):this.unexpected(),this.next(),this.finishNode(n,"Identifier"),t||this.checkUnreserved(n),n},ft.parseYield=function(){this.yieldPos||(this.yieldPos=this.start);var t=this.startNode();return this.next(),this.type===W.semi||this.canInsertSemicolon()||this.type!==W.star&&!this.type.startsExpr?(t.delegate=!1,t.argument=null):(t.delegate=this.eat(W.star),t.argument=this.parseMaybeAssign()),this.finishNode(t,"YieldExpression")},ft.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 mt=st.prototype;mt.raise=function(t,e){var n=u(this.input,t);e+=" ("+n.line+":"+n.column+")";var r=new SyntaxError(e);throw r.pos=t,r.loc=n,r.raisedAt=this.pos,r},mt.raiseRecoverable=mt.raise,mt.curPosition=function(){if(this.options.locations)return new et(this.curLine,this.pos-this.lineStart)};var gt=st.prototype,yt=Object.assign||function(t){for(var e=[],n=arguments.length-1;n-- >0;)e[n]=arguments[n+1];for(var r=0,i=e;r<i.length;r+=1){var s=i[r];for(var a in s)o(s,a)&&(t[a]=s[a])}return t};gt.enterFunctionScope=function(){this.scopeStack.push({"var":{},lexical:{},childVar:{},parentLexical:{}})},gt.exitFunctionScope=function(){this.scopeStack.pop()},gt.enterLexicalScope=function(){var t=this.scopeStack[this.scopeStack.length-1],e={"var":{},lexical:{},childVar:{},parentLexical:{}};this.scopeStack.push(e),yt(e.parentLexical,t.lexical,t.parentLexical)},gt.exitLexicalScope=function(){var t=this.scopeStack.pop(),e=this.scopeStack[this.scopeStack.length-1];yt(e.childVar,t["var"],t.childVar)},gt.canDeclareVarName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e.parentLexical,t)},gt.canDeclareLexicalName=function(t){var e=this.scopeStack[this.scopeStack.length-1];return!o(e.lexical,t)&&!o(e["var"],t)&&!o(e.childVar,t)},gt.declareVarName=function(t){this.scopeStack[this.scopeStack.length-1]["var"][t]=!0},gt.declareLexicalName=function(t){this.scopeStack[this.scopeStack.length-1].lexical[t]=!0};var xt=function(t,e,n){this.type="",this.start=e,this.end=0,t.options.locations&&(this.loc=new nt(t,n)),t.options.directSourceFile&&(this.sourceFile=t.options.directSourceFile),t.options.ranges&&(this.range=[e,0])},vt=st.prototype;vt.startNode=function(){return new xt(this,this.start,this.startLoc)},vt.startNodeAt=function(t,e){return new xt(this,t,e)},vt.finishNode=function(t,e){return f.call(this,t,e,this.lastTokEnd,this.lastTokEndLoc)},vt.finishNodeAt=function(t,e,n,r){return f.call(this,t,e,n,r)};var bt=function(t,e,n,r,i){this.token=t,this.isExpr=!!e,this.preserveSpace=!!n,this.override=r,this.generator=!!i},_t={b_stat:new bt("{",(!1)),b_expr:new bt("{",(!0)),b_tmpl:new bt("${",(!1)),p_stat:new bt("(",(!1)),p_expr:new bt("(",(!0)),q_tmpl:new bt("`",(!0),(!0),function(t){return t.tryReadTemplateToken()}),f_stat:new bt("function",(!1)),f_expr:new bt("function",(!0)),f_expr_gen:new bt("function",(!0),(!1),null,(!0)),f_gen:new bt("function",(!1),(!1),null,(!0))},Et=st.prototype;Et.initialContext=function(){return[_t.b_stat]},Et.braceIsBlock=function(t){var e=this.curContext();return e===_t.f_expr||e===_t.f_stat||(t!==W.colon||e!==_t.b_stat&&e!==_t.b_expr?t===W._return||t===W.name&&this.exprAllowed?H.test(this.input.slice(this.lastTokEnd,this.start)):t===W._else||t===W.semi||t===W.eof||t===W.parenR||t===W.arrow||(t===W.braceL?e===_t.b_stat:t!==W._var&&t!==W.name&&!this.exprAllowed):!e.isExpr)},Et.inGeneratorContext=function(){for(var t=this,e=this.context.length-1;e>=1;e--){var n=t.context[e];if("function"===n.token)return n.generator}return!1},Et.updateContext=function(t){var e,n=this.type;n.keyword&&t===W.dot?this.exprAllowed=!1:(e=n.updateContext)?e.call(this,t):this.exprAllowed=n.beforeExpr},W.parenR.updateContext=W.braceR.updateContext=function(){if(1===this.context.length)return void(this.exprAllowed=!0);var t=this.context.pop();t===_t.b_stat&&"function"===this.curContext().token&&(t=this.context.pop()),this.exprAllowed=!t.isExpr},W.braceL.updateContext=function(t){this.context.push(this.braceIsBlock(t)?_t.b_stat:_t.b_expr),this.exprAllowed=!0},W.dollarBraceL.updateContext=function(){this.context.push(_t.b_tmpl),this.exprAllowed=!0},W.parenL.updateContext=function(t){var e=t===W._if||t===W._for||t===W._with||t===W._while;this.context.push(e?_t.p_stat:_t.p_expr),this.exprAllowed=!0},W.incDec.updateContext=function(){},W._function.updateContext=W._class.updateContext=function(t){t.beforeExpr&&t!==W.semi&&t!==W._else&&(t!==W.colon&&t!==W.braceL||this.curContext()!==_t.b_stat)?this.context.push(_t.f_expr):this.context.push(_t.f_stat),this.exprAllowed=!1},W.backQuote.updateContext=function(){this.curContext()===_t.q_tmpl?this.context.pop():this.context.push(_t.q_tmpl),this.exprAllowed=!1},W.star.updateContext=function(t){if(t===W._function){var e=this.context.length-1;this.context[e]===_t.f_expr?this.context[e]=_t.f_expr_gen:this.context[e]=_t.f_gen}this.exprAllowed=!0},W.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 Tt={$LONE:["ASCII","ASCII_Hex_Digit","AHex","Alphabetic","Alpha","Any","Assigned","Bidi_Control","Bidi_C","Bidi_Mirrored","Bidi_M","Case_Ignorable","CI","Cased","Changes_When_Casefolded","CWCF","Changes_When_Casemapped","CWCM","Changes_When_Lowercased","CWL","Changes_When_NFKC_Casefolded","CWKCF","Changes_When_Titlecased","CWT","Changes_When_Uppercased","CWU","Dash","Default_Ignorable_Code_Point","DI","Deprecated","Dep","Diacritic","Dia","Emoji","Emoji_Component","Emoji_Modifier","Emoji_Modifier_Base","Emoji_Presentation","Extender","Ext","Grapheme_Base","Gr_Base","Grapheme_Extend","Gr_Ext","Hex_Digit","Hex","IDS_Binary_Operator","IDSB","IDS_Trinary_Operator","IDST","ID_Continue","IDC","ID_Start","IDS","Ideographic","Ideo","Join_Control","Join_C","Logical_Order_Exception","LOE","Lowercase","Lower","Math","Noncharacter_Code_Point","NChar","Pattern_Syntax","Pat_Syn","Pattern_White_Space","Pat_WS","Quotation_Mark","QMark","Radical","Regional_Indicator","RI","Sentence_Terminal","STerm","Soft_Dotted","SD","Terminal_Punctuation","Term","Unified_Ideograph","UIdeo","Uppercase","Upper","Variation_Selector","VS","White_Space","space","XID_Continue","XIDC","XID_Start","XIDS"],General_Category:["Cased_Letter","LC","Close_Punctuation","Pe","Connector_Punctuation","Pc","Control","Cc","cntrl","Currency_Symbol","Sc","Dash_Punctuation","Pd","Decimal_Number","Nd","digit","Enclosing_Mark","Me","Final_Punctuation","Pf","Format","Cf","Initial_Punctuation","Pi","Letter","L","Letter_Number","Nl","Line_Separator","Zl","Lowercase_Letter","Ll","Mark","M","Combining_Mark","Math_Symbol","Sm","Modifier_Letter","Lm","Modifier_Symbol","Sk","Nonspacing_Mark","Mn","Number","N","Open_Punctuation","Ps","Other","C","Other_Letter","Lo","Other_Number","No","Other_Punctuation","Po","Other_Symbol","So","Paragraph_Separator","Zp","Private_Use","Co","Punctuation","P","punct","Separator","Z","Space_Separator","Zs","Spacing_Mark","Mc","Surrogate","Cs","Symbol","S","Titlecase_Letter","Lt","Unassigned","Cn","Uppercase_Letter","Lu"],Script:["Adlam","Adlm","Ahom","Anatolian_Hieroglyphs","Hluw","Arabic","Arab","Armenian","Armn","Avestan","Avst","Balinese","Bali","Bamum","Bamu","Bassa_Vah","Bass","Batak","Batk","Bengali","Beng","Bhaiksuki","Bhks","Bopomofo","Bopo","Brahmi","Brah","Braille","Brai","Buginese","Bugi","Buhid","Buhd","Canadian_Aboriginal","Cans","Carian","Cari","Caucasian_Albanian","Aghb","Chakma","Cakm","Cham","Cherokee","Cher","Common","Zyyy","Coptic","Copt","Qaac","Cuneiform","Xsux","Cypriot","Cprt","Cyrillic","Cyrl","Deseret","Dsrt","Devanagari","Deva","Duployan","Dupl","Egyptian_Hieroglyphs","Egyp","Elbasan","Elba","Ethiopic","Ethi","Georgian","Geor","Glagolitic","Glag","Gothic","Goth","Grantha","Gran","Greek","Grek","Gujarati","Gujr","Gurmukhi","Guru","Han","Hani","Hangul","Hang","Hanunoo","Hano","Hatran","Hatr","Hebrew","Hebr","Hiragana","Hira","Imperial_Aramaic","Armi","Inherited","Zinh","Qaai","Inscriptional_Pahlavi","Phli","Inscriptional_Parthian","Prti","Javanese","Java","Kaithi","Kthi","Kannada","Knda","Katakana","Kana","Kayah_Li","Kali","Kharoshthi","Khar","Khmer","Khmr","Khojki","Khoj","Khudawadi","Sind","Lao","Laoo","Latin","Latn","Lepcha","Lepc","Limbu","Limb","Linear_A","Lina","Linear_B","Linb","Lisu","Lycian","Lyci","Lydian","Lydi","Mahajani","Mahj","Malayalam","Mlym","Mandaic","Mand","Manichaean","Mani","Marchen","Marc","Masaram_Gondi","Gonm","Meetei_Mayek","Mtei","Mende_Kikakui","Mend","Meroitic_Cursive","Merc","Meroitic_Hieroglyphs","Mero","Miao","Plrd","Modi","Mongolian","Mong","Mro","Mroo","Multani","Mult","Myanmar","Mymr","Nabataean","Nbat","New_Tai_Lue","Talu","Newa","Nko","Nkoo","Nushu","Nshu","Ogham","Ogam","Ol_Chiki","Olck","Old_Hungarian","Hung","Old_Italic","Ital","Old_North_Arabian","Narb","Old_Permic","Perm","Old_Persian","Xpeo","Old_South_Arabian","Sarb","Old_Turkic","Orkh","Oriya","Orya","Osage","Osge","Osmanya","Osma","Pahawh_Hmong","Hmng","Palmyrene","Palm","Pau_Cin_Hau","Pauc","Phags_Pa","Phag","Phoenician","Phnx","Psalter_Pahlavi","Phlp","Rejang","Rjng","Runic","Runr","Samaritan","Samr","Saurashtra","Saur","Sharada","Shrd","Shavian","Shaw","Siddham","Sidd","SignWriting","Sgnw","Sinhala","Sinh","Sora_Sompeng","Sora","Soyombo","Soyo","Sundanese","Sund","Syloti_Nagri","Sylo","Syriac","Syrc","Tagalog","Tglg","Tagbanwa","Tagb","Tai_Le","Tale","Tai_Tham","Lana","Tai_Viet","Tavt","Takri","Takr","Tamil","Taml","Tangut","Tang","Telugu","Telu","Thaana","Thaa","Thai","Tibetan","Tibt","Tifinagh","Tfng","Tirhuta","Tirh","Ugaritic","Ugar","Vai","Vaii","Warang_Citi","Wara","Yi","Yiii","Zanabazar_Square","Zanb"]};Array.prototype.push.apply(Tt.$LONE,Tt.General_Category),Tt.gc=Tt.General_Category,Tt.sc=Tt.Script_Extensions=Tt.scx=Tt.Script;var St=st.prototype,kt=function(t){this.parser=t,this.validFlags="gim"+(t.options.ecmaVersion>=6?"uy":"")+(t.options.ecmaVersion>=9?"s":""),this.source="",this.flags="",this.start=0,this.switchU=!1,this.switchN=!1,this.pos=0,this.lastIntValue=0,this.lastStringValue="",this.lastAssertionIsQuantifiable=!1,this.numCapturingParens=0,this.maxBackReference=0,this.groupNames=[],this.backReferenceNames=[]};kt.prototype.reset=function(t,e,n){var r=n.indexOf("u")!==-1;this.start=0|t,this.source=e+"",this.flags=n,this.switchU=r&&this.parser.options.ecmaVersion>=6,this.switchN=r&&this.parser.options.ecmaVersion>=9},kt.prototype.raise=function(t){this.parser.raiseRecoverable(this.start,"Invalid regular expression: /"+this.source+"/: "+t)},kt.prototype.at=function(t){var e=this.source,n=e.length;if(t>=n)return-1;var r=e.charCodeAt(t);return!this.switchU||r<=55295||r>=57344||t+1>=n?r:(r<<10)+e.charCodeAt(t+1)-56613888},kt.prototype.nextIndex=function(t){var e=this.source,n=e.length;if(t>=n)return n;var r=e.charCodeAt(t);return!this.switchU||r<=55295||r>=57344||t+1>=n?t+1:t+2},kt.prototype.current=function(){return this.at(this.pos)},kt.prototype.lookahead=function(){return this.at(this.nextIndex(this.pos))},kt.prototype.advance=function(){this.pos=this.nextIndex(this.pos)},kt.prototype.eat=function(t){return this.current()===t&&(this.advance(),!0)},St.validateRegExpFlags=function(t){for(var e=this,n=t.validFlags,r=t.flags,i=0;i<r.length;i++){var s=r.charAt(i);n.indexOf(s)===-1&&e.raise(t.start,"Invalid regular expression flag"),r.indexOf(s,i+1)>-1&&e.raise(t.start,"Duplicate regular expression flag")}},St.validateRegExpPattern=function(t){this.regexp_pattern(t),!t.switchN&&this.options.ecmaVersion>=9&&t.groupNames.length>0&&(t.switchN=!0,this.regexp_pattern(t))},St.regexp_pattern=function(t){t.pos=0,t.lastIntValue=0,t.lastStringValue="",t.lastAssertionIsQuantifiable=!1,t.numCapturingParens=0,t.maxBackReference=0,t.groupNames.length=0,t.backReferenceNames.length=0,this.regexp_disjunction(t),t.pos!==t.source.length&&(t.eat(41)&&t.raise("Unmatched ')'"),(t.eat(93)||t.eat(125))&&t.raise("Lone quantifier brackets")),t.maxBackReference>t.numCapturingParens&&t.raise("Invalid escape");for(var e=0,n=t.backReferenceNames;e<n.length;e+=1){var r=n[e];t.groupNames.indexOf(r)===-1&&t.raise("Invalid named capture referenced")}},St.regexp_disjunction=function(t){var e=this;for(this.regexp_alternative(t);t.eat(124);)e.regexp_alternative(t);this.regexp_eatQuantifier(t,!0)&&t.raise("Nothing to repeat"),t.eat(123)&&t.raise("Lone quantifier brackets")},St.regexp_alternative=function(t){for(;t.pos<t.source.length&&this.regexp_eatTerm(t););},St.regexp_eatTerm=function(t){return this.regexp_eatAssertion(t)?(t.lastAssertionIsQuantifiable&&this.regexp_eatQuantifier(t)&&t.switchU&&t.raise("Invalid quantifier"),!0):!(t.switchU?!this.regexp_eatAtom(t):!this.regexp_eatExtendedAtom(t))&&(this.regexp_eatQuantifier(t),!0)},St.regexp_eatAssertion=function(t){var e=t.pos;if(t.lastAssertionIsQuantifiable=!1,t.eat(94)||t.eat(36))return!0;if(t.eat(92)){if(t.eat(66)||t.eat(98))return!0;t.pos=e}if(t.eat(40)&&t.eat(63)){var n=!1;if(this.options.ecmaVersion>=9&&(n=t.eat(60)),t.eat(61)||t.eat(33))return this.regexp_disjunction(t),t.eat(41)||t.raise("Unterminated group"),t.lastAssertionIsQuantifiable=!n,!0}return t.pos=e,!1},St.regexp_eatQuantifier=function(t,e){return void 0===e&&(e=!1),!!this.regexp_eatQuantifierPrefix(t,e)&&(t.eat(63),!0)},St.regexp_eatQuantifierPrefix=function(t,e){return t.eat(42)||t.eat(43)||t.eat(63)||this.regexp_eatBracedQuantifier(t,e)},St.regexp_eatBracedQuantifier=function(t,e){var n=t.pos;if(t.eat(123)){var r=0,i=-1;if(this.regexp_eatDecimalDigits(t)&&(r=t.lastIntValue,t.eat(44)&&this.regexp_eatDecimalDigits(t)&&(i=t.lastIntValue),t.eat(125)))return i!==-1&&i<r&&!e&&t.raise("numbers out of order in {} quantifier"),!0;t.switchU&&!e&&t.raise("Incomplete quantifier"),t.pos=n}return!1},St.regexp_eatAtom=function(t){return this.regexp_eatPatternCharacters(t)||t.eat(46)||this.regexp_eatReverseSolidusAtomEscape(t)||this.regexp_eatCharacterClass(t)||this.regexp_eatUncapturingGroup(t)||this.regexp_eatCapturingGroup(t)},St.regexp_eatReverseSolidusAtomEscape=function(t){var e=t.pos;if(t.eat(92)){if(this.regexp_eatAtomEscape(t))return!0;t.pos=e}return!1},St.regexp_eatUncapturingGroup=function(t){var e=t.pos;if(t.eat(40)){if(t.eat(63)&&t.eat(58)){if(this.regexp_disjunction(t),t.eat(41))return!0;t.raise("Unterminated group")}t.pos=e}return!1},St.regexp_eatCapturingGroup=function(t){if(t.eat(40)){if(this.options.ecmaVersion>=9?this.regexp_groupSpecifier(t):63===t.current()&&t.raise("Invalid group"),this.regexp_disjunction(t),t.eat(41))return t.numCapturingParens+=1,!0;t.raise("Unterminated group")}return!1},St.regexp_eatExtendedAtom=function(t){return t.eat(46)||this.regexp_eatReverseSolidusAtomEscape(t)||this.regexp_eatCharacterClass(t)||this.regexp_eatUncapturingGroup(t)||this.regexp_eatCapturingGroup(t)||this.regexp_eatInvalidBracedQuantifier(t)||this.regexp_eatExtendedPatternCharacter(t)},St.regexp_eatInvalidBracedQuantifier=function(t){return this.regexp_eatBracedQuantifier(t,!0)&&t.raise("Nothing to repeat"),!1},St.regexp_eatSyntaxCharacter=function(t){var e=t.current();return!!m(e)&&(t.lastIntValue=e,t.advance(),!0)},St.regexp_eatPatternCharacters=function(t){for(var e=t.pos,n=0;(n=t.current())!==-1&&!m(n);)t.advance();return t.pos!==e},St.regexp_eatExtendedPatternCharacter=function(t){var e=t.current();return!(e===-1||36===e||e>=40&&e<=43||46===e||63===e||91===e||94===e||124===e)&&(t.advance(),!0)},St.regexp_groupSpecifier=function(t){if(t.eat(63)){if(this.regexp_eatGroupName(t))return t.groupNames.indexOf(t.lastStringValue)!==-1&&t.raise("Duplicate capture group name"),void t.groupNames.push(t.lastStringValue);t.raise("Invalid group")}},St.regexp_eatGroupName=function(t){if(t.lastStringValue="",t.eat(60)){if(this.regexp_eatRegExpIdentifierName(t)&&t.eat(62))return!0;t.raise("Invalid capture group name")}return!1},St.regexp_eatRegExpIdentifierName=function(t){if(t.lastStringValue="",this.regexp_eatRegExpIdentifierStart(t)){for(t.lastStringValue+=d(t.lastIntValue);this.regexp_eatRegExpIdentifierPart(t);)t.lastStringValue+=d(t.lastIntValue);return!0}return!1},St.regexp_eatRegExpIdentifierStart=function(t){var e=t.pos,n=t.current();return t.advance(),92===n&&this.regexp_eatRegExpUnicodeEscapeSequence(t)&&(n=t.lastIntValue),g(n)?(t.lastIntValue=n,!0):(t.pos=e,!1)},St.regexp_eatRegExpIdentifierPart=function(t){var e=t.pos,n=t.current();return t.advance(),92===n&&this.regexp_eatRegExpUnicodeEscapeSequence(t)&&(n=t.lastIntValue),y(n)?(t.lastIntValue=n,!0):(t.pos=e,!1)},St.regexp_eatAtomEscape=function(t){return!!(this.regexp_eatBackReference(t)||this.regexp_eatCharacterClassEscape(t)||this.regexp_eatCharacterEscape(t)||t.switchN&&this.regexp_eatKGroupName(t))||(t.switchU&&(99===t.current()&&t.raise("Invalid unicode escape"),t.raise("Invalid escape")),!1)},St.regexp_eatBackReference=function(t){var e=t.pos;if(this.regexp_eatDecimalEscape(t)){var n=t.lastIntValue;if(t.switchU)return n>t.maxBackReference&&(t.maxBackReference=n),!0;if(n<=t.numCapturingParens)return!0;t.pos=e}return!1},St.regexp_eatKGroupName=function(t){if(t.eat(107)){if(this.regexp_eatGroupName(t))return t.backReferenceNames.push(t.lastStringValue),!0;t.raise("Invalid named reference")}return!1},St.regexp_eatCharacterEscape=function(t){return this.regexp_eatControlEscape(t)||this.regexp_eatCControlLetter(t)||this.regexp_eatZero(t)||this.regexp_eatHexEscapeSequence(t)||this.regexp_eatRegExpUnicodeEscapeSequence(t)||!t.switchU&&this.regexp_eatLegacyOctalEscapeSequence(t)||this.regexp_eatIdentityEscape(t)},St.regexp_eatCControlLetter=function(t){var e=t.pos;if(t.eat(99)){if(this.regexp_eatControlLetter(t))return!0;t.pos=e}return!1},St.regexp_eatZero=function(t){return 48===t.current()&&!T(t.lookahead())&&(t.lastIntValue=0,t.advance(),!0)},St.regexp_eatControlEscape=function(t){var e=t.current();return 116===e?(t.lastIntValue=9,t.advance(),!0):110===e?(t.lastIntValue=10,t.advance(),!0):118===e?(t.lastIntValue=11,t.advance(),!0):102===e?(t.lastIntValue=12,t.advance(),!0):114===e&&(t.lastIntValue=13,t.advance(),!0)},St.regexp_eatControlLetter=function(t){var e=t.current();return!!x(e)&&(t.lastIntValue=e%32,t.advance(),!0)},St.regexp_eatRegExpUnicodeEscapeSequence=function(t){var e=t.pos;if(t.eat(117)){if(this.regexp_eatFixedHexDigits(t,4)){var n=t.lastIntValue;if(t.switchU&&n>=55296&&n<=56319){var r=t.pos;if(t.eat(92)&&t.eat(117)&&this.regexp_eatFixedHexDigits(t,4)){var i=t.lastIntValue;if(i>=56320&&i<=57343)return t.lastIntValue=1024*(n-55296)+(i-56320)+65536,!0}t.pos=r,t.lastIntValue=n}return!0}if(t.switchU&&t.eat(123)&&this.regexp_eatHexDigits(t)&&t.eat(125)&&v(t.lastIntValue))return!0;t.switchU&&t.raise("Invalid unicode escape"),t.pos=e}return!1},St.regexp_eatIdentityEscape=function(t){if(t.switchU)return!!this.regexp_eatSyntaxCharacter(t)||!!t.eat(47)&&(t.lastIntValue=47,!0);var e=t.current();return!(99===e||t.switchN&&107===e)&&(t.lastIntValue=e,t.advance(),!0)},St.regexp_eatDecimalEscape=function(t){t.lastIntValue=0;var e=t.current();if(e>=49&&e<=57){do t.lastIntValue=10*t.lastIntValue+(e-48),t.advance();while((e=t.current())>=48&&e<=57);return!0}return!1},St.regexp_eatCharacterClassEscape=function(t){var e=t.current();if(b(e))return t.lastIntValue=-1,t.advance(),!0;if(t.switchU&&this.options.ecmaVersion>=9&&(80===e||112===e)){if(t.lastIntValue=-1,t.advance(),t.eat(123)&&this.regexp_eatUnicodePropertyValueExpression(t)&&t.eat(125))return!0;t.raise("Invalid property name")}return!1},St.regexp_eatUnicodePropertyValueExpression=function(t){var e=t.pos;if(this.regexp_eatUnicodePropertyName(t)&&t.eat(61)){var n=t.lastStringValue;if(this.regexp_eatUnicodePropertyValue(t)){var r=t.lastStringValue;return this.regexp_validateUnicodePropertyNameAndValue(t,n,r),!0}}if(t.pos=e,this.regexp_eatLoneUnicodePropertyNameOrValue(t)){var i=t.lastStringValue;return this.regexp_validateUnicodePropertyNameOrValue(t,i),!0}return!1},St.regexp_validateUnicodePropertyNameAndValue=function(t,e,n){Tt.hasOwnProperty(e)&&Tt[e].indexOf(n)!==-1||t.raise("Invalid property name")},St.regexp_validateUnicodePropertyNameOrValue=function(t,e){Tt.$LONE.indexOf(e)===-1&&t.raise("Invalid property name")},St.regexp_eatUnicodePropertyName=function(t){var e=0;for(t.lastStringValue="";_(e=t.current());)t.lastStringValue+=d(e),t.advance();return""!==t.lastStringValue},St.regexp_eatUnicodePropertyValue=function(t){var e=0;for(t.lastStringValue="";E(e=t.current());)t.lastStringValue+=d(e),t.advance();return""!==t.lastStringValue},St.regexp_eatLoneUnicodePropertyNameOrValue=function(t){return this.regexp_eatUnicodePropertyValue(t)},St.regexp_eatCharacterClass=function(t){if(t.eat(91)){if(t.eat(94),this.regexp_classRanges(t),t.eat(93))return!0;t.raise("Unterminated character class")}return!1},St.regexp_classRanges=function(t){for(var e=this;this.regexp_eatClassAtom(t);){var n=t.lastIntValue;if(t.eat(45)&&e.regexp_eatClassAtom(t)){var r=t.lastIntValue;!t.switchU||n!==-1&&r!==-1||t.raise("Invalid character class"),n!==-1&&r!==-1&&n>r&&t.raise("Range out of order in character class")}}},St.regexp_eatClassAtom=function(t){var e=t.pos;if(t.eat(92)){if(this.regexp_eatClassEscape(t))return!0;if(t.switchU){var n=t.current();(99===n||A(n))&&t.raise("Invalid class escape"),t.raise("Invalid escape")}t.pos=e}var r=t.current();return 93!==r&&(t.lastIntValue=r,t.advance(),!0)},St.regexp_eatClassEscape=function(t){var e=t.pos;if(t.eat(98))return t.lastIntValue=8,!0;if(t.switchU&&t.eat(45))return t.lastIntValue=45,!0;if(!t.switchU&&t.eat(99)){if(this.regexp_eatClassControlLetter(t))return!0;t.pos=e}return this.regexp_eatCharacterClassEscape(t)||this.regexp_eatCharacterEscape(t)},St.regexp_eatClassControlLetter=function(t){var e=t.current();return!(!T(e)&&95!==e)&&(t.lastIntValue=e%32,t.advance(),!0)},St.regexp_eatHexEscapeSequence=function(t){var e=t.pos;if(t.eat(120)){if(this.regexp_eatFixedHexDigits(t,2))return!0;t.switchU&&t.raise("Invalid escape"),t.pos=e}return!1},St.regexp_eatDecimalDigits=function(t){var e=t.pos,n=0;for(t.lastIntValue=0;T(n=t.current());)t.lastIntValue=10*t.lastIntValue+(n-48),t.advance();return t.pos!==e},St.regexp_eatHexDigits=function(t){var e=t.pos,n=0;for(t.lastIntValue=0;S(n=t.current());)t.lastIntValue=16*t.lastIntValue+k(n),t.advance();return t.pos!==e},St.regexp_eatLegacyOctalEscapeSequence=function(t){if(this.regexp_eatOctalDigit(t)){var e=t.lastIntValue;if(this.regexp_eatOctalDigit(t)){var n=t.lastIntValue;e<=3&&this.regexp_eatOctalDigit(t)?t.lastIntValue=64*e+8*n+t.lastIntValue:t.lastIntValue=8*e+n}else t.lastIntValue=e;return!0}return!1},St.regexp_eatOctalDigit=function(t){var e=t.current();return A(e)?(t.lastIntValue=e-48,t.advance(),!0):(t.lastIntValue=0,!1)},St.regexp_eatFixedHexDigits=function(t,e){var n=t.pos;t.lastIntValue=0;for(var r=0;r<e;++r){var i=t.current();if(!S(i))return t.pos=n,!1;t.lastIntValue=16*t.lastIntValue+k(i),t.advance()}return!0};var At=function(t){this.type=t.type,this.value=t.value,this.start=t.start,this.end=t.end,t.options.locations&&(this.loc=new nt(t,t.startLoc,t.endLoc)),t.options.ranges&&(this.range=[t.start,t.end])},wt=st.prototype;wt.next=function(){this.options.onToken&&this.options.onToken(new At(this)),this.lastTokEnd=this.end,this.lastTokStart=this.start,this.lastTokEndLoc=this.endLoc,this.lastTokStartLoc=this.startLoc,this.nextToken()},wt.getToken=function(){return this.next(),new At(this)},"undefined"!=typeof Symbol&&(wt[Symbol.iterator]=function(){var t=this;return{next:function(){var e=t.getToken();return{done:e.type===W.eof,value:e}}}}),wt.curContext=function(){return this.context[this.context.length-1];
+},wt.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(W.eof):t.override?t.override(this):void this.readToken(this.fullCharCodeAtPos())},wt.readToken=function(t){return n(t,this.options.ecmaVersion>=6)||92===t?this.readWord():this.getTokenFromCode(t)},wt.fullCharCodeAtPos=function(){var t=this.input.charCodeAt(this.pos);if(t<=55295||t>=57344)return t;var e=this.input.charCodeAt(this.pos+1);return(t<<10)+e-56613888},wt.skipBlockComment=function(){var t=this,e=this.options.onComment&&this.curPosition(),n=this.pos,r=this.input.indexOf("*/",this.pos+=2);if(r===-1&&this.raise(this.pos-2,"Unterminated comment"),this.pos=r+2,this.options.locations){Y.lastIndex=n;for(var i;(i=Y.exec(this.input))&&i.index<this.pos;)++t.curLine,t.lineStart=i.index+i[0].length}this.options.onComment&&this.options.onComment(!0,this.input.slice(n+2,r),n,this.pos,e,this.curPosition())},wt.skipLineComment=function(t){for(var e=this,n=this.pos,r=this.options.onComment&&this.curPosition(),i=this.input.charCodeAt(this.pos+=t);this.pos<this.input.length&&!a(i);)i=e.input.charCodeAt(++e.pos);this.options.onComment&&this.options.onComment(!1,this.input.slice(n+t,this.pos),n,this.pos,r,this.curPosition())},wt.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&&q.test(String.fromCharCode(e))))break t;++t.pos}}},wt.finishToken=function(t,e){this.end=this.pos,this.options.locations&&(this.endLoc=this.curPosition());var n=this.type;this.type=t,this.value=e,this.updateContext(n)},wt.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(W.ellipsis)):(++this.pos,this.finishToken(W.dot))},wt.readToken_slash=function(){var t=this.input.charCodeAt(this.pos+1);return this.exprAllowed?(++this.pos,this.readRegexp()):61===t?this.finishOp(W.assign,2):this.finishOp(W.slash,1)},wt.readToken_mult_modulo_exp=function(t){var e=this.input.charCodeAt(this.pos+1),n=1,r=42===t?W.star:W.modulo;return this.options.ecmaVersion>=7&&42===t&&42===e&&(++n,r=W.starstar,e=this.input.charCodeAt(this.pos+2)),61===e?this.finishOp(W.assign,n+1):this.finishOp(r,n)},wt.readToken_pipe_amp=function(t){var e=this.input.charCodeAt(this.pos+1);return e===t?this.finishOp(124===t?W.logicalOR:W.logicalAND,2):61===e?this.finishOp(W.assign,2):this.finishOp(124===t?W.bitwiseOR:W.bitwiseAND,1)},wt.readToken_caret=function(){var t=this.input.charCodeAt(this.pos+1);return 61===t?this.finishOp(W.assign,2):this.finishOp(W.bitwiseXOR,1)},wt.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&&!H.test(this.input.slice(this.lastTokEnd,this.pos))?this.finishOp(W.incDec,2):(this.skipLineComment(3),this.skipSpace(),this.nextToken()):61===e?this.finishOp(W.assign,2):this.finishOp(W.plusMin,1)},wt.readToken_lt_gt=function(t){var e=this.input.charCodeAt(this.pos+1),n=1;return e===t?(n=62===t&&62===this.input.charCodeAt(this.pos+2)?3:2,61===this.input.charCodeAt(this.pos+n)?this.finishOp(W.assign,n+1):this.finishOp(W.bitShift,n)):33!==e||60!==t||this.inModule||45!==this.input.charCodeAt(this.pos+2)||45!==this.input.charCodeAt(this.pos+3)?(61===e&&(n=2),this.finishOp(W.relational,n)):(this.skipLineComment(4),this.skipSpace(),this.nextToken())},wt.readToken_eq_excl=function(t){var e=this.input.charCodeAt(this.pos+1);return 61===e?this.finishOp(W.equality,61===this.input.charCodeAt(this.pos+2)?3:2):61===t&&62===e&&this.options.ecmaVersion>=6?(this.pos+=2,this.finishToken(W.arrow)):this.finishOp(61===t?W.eq:W.prefix,1)},wt.getTokenFromCode=function(t){switch(t){case 46:return this.readToken_dot();case 40:return++this.pos,this.finishToken(W.parenL);case 41:return++this.pos,this.finishToken(W.parenR);case 59:return++this.pos,this.finishToken(W.semi);case 44:return++this.pos,this.finishToken(W.comma);case 91:return++this.pos,this.finishToken(W.bracketL);case 93:return++this.pos,this.finishToken(W.bracketR);case 123:return++this.pos,this.finishToken(W.braceL);case 125:return++this.pos,this.finishToken(W.braceR);case 58:return++this.pos,this.finishToken(W.colon);case 63:return++this.pos,this.finishToken(W.question);case 96:if(this.options.ecmaVersion<6)break;return++this.pos,this.finishToken(W.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(W.prefix,1)}this.raise(this.pos,"Unexpected character '"+w(t)+"'")},wt.finishOp=function(t,e){var n=this.input.slice(this.pos,this.pos+e);return this.pos+=e,this.finishToken(t,n)},wt.readRegexp=function(){for(var t,e,n=this,r=this.pos;;){n.pos>=n.input.length&&n.raise(r,"Unterminated regular expression");var i=n.input.charAt(n.pos);if(H.test(i)&&n.raise(r,"Unterminated regular expression"),t)t=!1;else{if("["===i)e=!0;else if("]"===i&&e)e=!1;else if("/"===i&&!e)break;t="\\"===i}++n.pos}var s=this.input.slice(r,this.pos);++this.pos;var a=this.pos,o=this.readWord1();this.containsEsc&&this.unexpected(a);var u=this.regexpState||(this.regexpState=new kt(this));u.reset(r,s,o),this.validateRegExpFlags(u),this.validateRegExpPattern(u);var h=null;try{h=new RegExp(s,o)}catch(c){}return this.finishToken(W.regexp,{pattern:s,flags:o,value:h})},wt.readInt=function(t,e){for(var n=this,r=this.pos,i=0,s=0,a=null==e?1/0:e;s<a;++s){var o=n.input.charCodeAt(n.pos),u=void 0;if(u=o>=97?o-97+10:o>=65?o-65+10:o>=48&&o<=57?o-48:1/0,u>=t)break;++n.pos,i=i*t+u}return this.pos===r||null!=e&&this.pos-r!==e?null:i},wt.readRadixNumber=function(t){this.pos+=2;var e=this.readInt(t);return null==e&&this.raise(this.start+2,"Expected number in radix "+t),n(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number"),this.finishToken(W.num,e)},wt.readNumber=function(t){var e=this.pos;t||null!==this.readInt(10)||this.raise(e,"Invalid number");var r=this.pos-e>=2&&48===this.input.charCodeAt(e);r&&this.strict&&this.raise(e,"Invalid number"),r&&/[89]/.test(this.input.slice(e,this.pos))&&(r=!1);var i=this.input.charCodeAt(this.pos);46!==i||r||(++this.pos,this.readInt(10),i=this.input.charCodeAt(this.pos)),69!==i&&101!==i||r||(i=this.input.charCodeAt(++this.pos),43!==i&&45!==i||++this.pos,null===this.readInt(10)&&this.raise(e,"Invalid number")),n(this.fullCharCodeAtPos())&&this.raise(this.pos,"Identifier directly after number");var s=this.input.slice(e,this.pos),a=r?parseInt(s,8):parseFloat(s);return this.finishToken(W.num,a)},wt.readCodePoint=function(){var t,e=this.input.charCodeAt(this.pos);if(123===e){this.options.ecmaVersion<6&&this.unexpected();var n=++this.pos;t=this.readHexChar(this.input.indexOf("}",this.pos)-this.pos),++this.pos,t>1114111&&this.invalidStringToken(n,"Code point out of bounds")}else t=this.readHexChar(4);return t},wt.readString=function(t){for(var e=this,n="",r=++this.pos;;){e.pos>=e.input.length&&e.raise(e.start,"Unterminated string constant");var i=e.input.charCodeAt(e.pos);if(i===t)break;92===i?(n+=e.input.slice(r,e.pos),n+=e.readEscapedChar(!1),r=e.pos):(a(i,e.options.ecmaVersion>=10)&&e.raise(e.start,"Unterminated string constant"),++e.pos)}return n+=this.input.slice(r,this.pos++),this.finishToken(W.string,n)};var Rt={};wt.tryReadTemplateToken=function(){this.inTemplateElement=!0;try{this.readTmplToken()}catch(t){if(t!==Rt)throw t;this.readInvalidTemplateToken()}this.inTemplateElement=!1},wt.invalidStringToken=function(t,e){if(this.inTemplateElement&&this.options.ecmaVersion>=9)throw Rt;this.raise(t,e)},wt.readTmplToken=function(){for(var t=this,e="",n=this.pos;;){t.pos>=t.input.length&&t.raise(t.start,"Unterminated template");var r=t.input.charCodeAt(t.pos);if(96===r||36===r&&123===t.input.charCodeAt(t.pos+1))return t.pos!==t.start||t.type!==W.template&&t.type!==W.invalidTemplate?(e+=t.input.slice(n,t.pos),t.finishToken(W.template,e)):36===r?(t.pos+=2,t.finishToken(W.dollarBraceL)):(++t.pos,t.finishToken(W.backQuote));if(92===r)e+=t.input.slice(n,t.pos),e+=t.readEscapedChar(!0),n=t.pos;else if(a(r)){switch(e+=t.input.slice(n,t.pos),++t.pos,r){case 13:10===t.input.charCodeAt(t.pos)&&++t.pos;case 10:e+="\n";break;default:e+=String.fromCharCode(r)}t.options.locations&&(++t.curLine,t.lineStart=t.pos),n=t.pos}else++t.pos}},wt.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(W.invalidTemplate,t.input.slice(t.start,t.pos))}this.raise(this.start,"Unterminated template")},wt.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 w(this.readCodePoint());case 116:return"\t";case 98:return"\b";case 118:return"\x0B";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 n=this.input.substr(this.pos-1,3).match(/^[0-7]+/)[0],r=parseInt(n,8);return r>255&&(n=n.slice(0,-1),r=parseInt(n,8)),this.pos+=n.length-1,e=this.input.charCodeAt(this.pos),"0"===n&&56!==e&&57!==e||!this.strict&&!t||this.invalidStringToken(this.pos-1-n.length,t?"Octal literal in template string":"Octal literal in strict mode"),String.fromCharCode(r)}return String.fromCharCode(e)}},wt.readHexChar=function(t){var e=this.pos,n=this.readInt(16,t);return null===n&&this.invalidStringToken(e,"Bad character escape sequence"),n},wt.readWord1=function(){var t=this;this.containsEsc=!1;for(var e="",i=!0,s=this.pos,a=this.options.ecmaVersion>=6;this.pos<this.input.length;){var o=t.fullCharCodeAtPos();if(r(o,a))t.pos+=o<=65535?1:2;else{if(92!==o)break;t.containsEsc=!0,e+=t.input.slice(s,t.pos);var u=t.pos;117!==t.input.charCodeAt(++t.pos)&&t.invalidStringToken(t.pos,"Expecting Unicode escape sequence \\uXXXX"),++t.pos;var h=t.readCodePoint();(i?n:r)(h,a)||t.invalidStringToken(u,"Invalid Unicode escape"),e+=w(h),s=t.pos}i=!1}return e+this.input.slice(s,this.pos)},wt.readWord=function(){var t=this.readWord1(),e=W.name;return this.keywords.test(t)&&(this.containsEsc&&this.raiseRecoverable(this.start,"Escape sequence in keyword "+t),e=K[t]),this.finishToken(e,t)};var Ot="5.7.1";t.version=Ot,t.parse=R,t.parseExpressionAt=O,t.tokenizer=D,t.addLooseExports=C,t.Parser=st,t.plugins=it,t.defaultOptions=rt,t.Position=et,t.SourceLocation=nt,t.getLineInfo=u,t.Node=xt,t.TokenType=V,t.tokTypes=W,t.keywordTypes=K,t.TokContext=bt,t.tokContexts=_t,t.isIdentifierChar=r,t.isIdentifierStart=n,t.Token=At,t.isNewLine=a,t.lineBreak=H,t.lineBreakG=Y,t.nonASCIIwhitespace=q,Object.defineProperty(t,"__esModule",{value:!0})})},{}]},{},[33]);
\ No newline at end of file
diff --git a/dist/backend/kernel-base.js b/dist/backend/kernel-base.js
new file mode 100644
index 00000000..51991406
--- /dev/null
+++ b/dist/backend/kernel-base.js
@@ -0,0 +1,528 @@
+'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');
+var Input = require('../core/input');
+
+module.exports = function () {
+
+	/**
+  * @constructor KernelBase
+  *
+  * @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
+  * @prop {Boolean} fixIntegerDivisionAccuracy - fix issues with some graphics cards not returning whole numbers when dividing by factors of 3
+  *
+  */
+	function KernelBase(fnString, settings) {
+		_classCallCheck(this, KernelBase);
+
+		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.outputImmutable = 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.subKernels = null;
+		this.subKernelProperties = null;
+		this.subKernelNames = null;
+		this.subKernelOutputVariableNames = null;
+		this.functionBuilder = null;
+		this.paramTypes = null;
+		this.paramSizes = null;
+		this.constantTypes = null;
+		this.fixIntegerDivisionAccuracy = null;
+		this.constrainStart = null;
+		this.constrainEnd = 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;
+		}
+		if (settings.hasOwnProperty('webGl')) {
+			this._webGl = settings.webGl;
+		}
+		if (settings.hasOwnProperty('output')) {
+			this.setOutput(settings.output); // Flatten output object
+		}
+
+		if (!this._canvas) this._canvas = utils.initCanvas();
+	}
+
+	_createClass(KernelBase, [{
+		key: 'build',
+		value: function build() {
+			throw new Error('"build" not defined on Base');
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setupParams
+   *
+   * @desc Setup the parameter types for the parameters
+   * supplied to the Kernel function
+   *
+   * @param {IArguments} args - The actual parameters sent to the Kernel
+   *
+   */
+
+	}, {
+		key: 'setupParams',
+		value: function setupParams(args) {
+			this.paramTypes = [];
+			this.paramSizes = [];
+			for (var i = 0; i < args.length; i++) {
+				var arg = args[i];
+
+				this.paramTypes.push(utils.getArgumentType(arg));
+				this.paramSizes.push(arg.constructor === Input ? arg.size : null);
+			}
+		}
+	}, {
+		key: 'setupConstants',
+		value: function setupConstants() {
+			this.constantTypes = {};
+			if (this.constants) {
+				for (var p in this.constants) {
+					this.constantTypes[p] = utils.getArgumentType(this.constants[p]);
+				}
+			}
+		}
+	}, {
+		key: 'setFunctions',
+		value: function setFunctions(functions) {
+			this.functions = functions;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setOutput
+   *
+   * @desc Set dimensions of the kernel function
+   *
+   * @param {Array|Object} output - The output array to set the kernel output size to
+   *
+   */
+
+	}, {
+		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;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setDebug
+   *
+   * @desc Toggle debug mode
+   *
+   * @param {Boolean} flag - true to enable debug
+   *
+   */
+
+	}, {
+		key: 'setDebug',
+		value: function setDebug(flag) {
+			this.debug = flag;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setGraphical
+   *
+   * @desc Toggle graphical output mode
+   *
+   * @param {Boolean} flag - true to enable graphical output
+   *
+   */
+
+	}, {
+		key: 'setGraphical',
+		value: function setGraphical(flag) {
+			this.graphical = flag;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name constrain
+   *
+   * @desc constrain kernel to operate on subset quad of matrix
+   *
+   * @param {Array} start - [x, y, z]
+   * @param {Array} end - [x, y, z]
+   *
+   */
+
+	}, {
+		key: 'constrain',
+		value: function constrain(start, end) {
+			this.constrainStart = start || null;
+			this.constrainEnd = end || null;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name deconstrain
+   *
+   * @desc remove constraint on kernelin order to operate on entire matrix
+   */
+
+	}, {
+		key: 'deconstrain',
+		value: function deconstrain() {
+			this.constrainStart = null;
+			this.constrainEnd = null;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setLoopMaxIterations
+   *
+   * @desc Set the maximum number of loop iterations
+   *
+   * @param {number} max - iterations count
+   *
+   */
+
+	}, {
+		key: 'setLoopMaxIterations',
+		value: function setLoopMaxIterations(max) {
+			this.loopMaxIterations = max;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setFixIntegerDivisionAccuracy
+   *
+   * @desc Fix division by factor of 3 FP accuracy bug
+   *
+   * @param {Boolean} fix - should fix
+   *
+   */
+
+	}, {
+		key: 'setFixIntegerDivisionAccuracy',
+		value: function setFixIntegerDivisionAccuracy(fix) {
+			this.fixIntegerDivisionAccuracy = fix;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setConstants
+   * @desc Set Constants
+   */
+
+	}, {
+		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;
+		}
+	}, {
+		key: 'setOutputImmutable',
+		value: function setOutputImmutable(flag) {
+			this.outputImmutable = flag;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setFloatTextures
+   *
+   * @desc Toggle texture output mode
+   *
+   * @param {Boolean} flag - true to enable floatTextures
+   *
+   */
+
+	}, {
+		key: 'setFloatTextures',
+		value: function setFloatTextures(flag) {
+			this.floatTextures = flag;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setFloatOutput
+   *
+   * @desc Toggle output mode
+   *
+   * @param {Boolean} flag - true to enable float
+   *
+   */
+
+	}, {
+		key: 'setFloatOutput',
+		value: function setFloatOutput(flag) {
+			this.floatOutput = flag;
+			return this;
+		}
+	}, {
+		key: 'setFloatOutputForce',
+		value: function setFloatOutputForce(flag) {
+			this.floatOutputForce = flag;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setCanvas
+   *
+   * @desc Bind the canvas to kernel
+   *
+   * @param {Canvas} canvas - Canvas to bind
+   *
+   */
+
+	}, {
+		key: 'setCanvas',
+		value: function setCanvas(canvas) {
+			this._canvas = canvas;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name setCanvas
+   *
+   * @desc Bind the webGL instance to kernel
+   *
+   * @param {Canvas} webGL - webGL instance to bind
+   *
+   */
+
+	}, {
+		key: 'setWebGl',
+		value: function setWebGl(webGl) {
+			this._webGl = webGl;
+			return this;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name getCanvas()
+   *
+   * @desc Returns the current canvas instance bound to the kernel
+   *
+   */
+
+	}, {
+		key: 'getCanvas',
+		value: function getCanvas() {
+			return this._canvas;
+		}
+
+		/**
+   * @memberOf KernelBase#
+   * @function
+   * @name getWebGl()
+   *
+   * @desc Returns the current webGl instance bound to the kernel
+   *
+   */
+
+	}, {
+		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 KernelBase#
+   * @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
+   *
+   */
+
+	}, {
+		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 KernelBase#
+   * @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
+   *
+   */
+
+	}, {
+		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);
+		}
+
+		/**
+   *
+   * Destroys all memory associated with this kernel
+   *
+   * @name destroy
+   * @function
+   * @memberOf KernelBase#
+   *
+   * * @param {Boolean} removeCanvasReferences remve any associated canvas references?
+   *
+   */
+
+	}, {
+		key: 'destroy',
+		value: function destroy() {}
+	}]);
+
+	return KernelBase;
+}();
\ No newline at end of file
diff --git a/dist/backend/web-gl/kernel.js b/dist/backend/web-gl/kernel.js
new file mode 100644
index 00000000..8e335f73
--- /dev/null
+++ b/dist/backend/web-gl/kernel.js
@@ -0,0 +1,1729 @@
+'use strict';
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+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 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 = {};
+
+module.exports = function (_KernelBase) {
+	_inherits(WebGLKernel, _KernelBase);
+
+	_createClass(WebGLKernel, null, [{
+		key: 'fragShaderString',
+		get: function get() {
+			return fragShaderString;
+		}
+	}, {
+		key: 'vertShaderString',
+		get: function get() {
+			return vertShaderString;
+		}
+		/**
+   * @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 _this = _possibleConstructorReturn(this, (WebGLKernel.__proto__ || Object.getPrototypeOf(WebGLKernel)).call(this, fnString, settings));
+
+		_this.textureCache = {};
+		_this.threadDim = {};
+		_this.programUniformLocationCache = {};
+		_this.framebuffer = null;
+
+		_this.buffer = null;
+		_this.program = null;
+		_this.outputToTexture = settings.outputToTexture;
+		_this.endianness = utils.systemEndianness();
+		_this.subKernelOutputTextures = null;
+		_this.subKernelOutputVariableNames = null;
+		_this.argumentsLength = 0;
+		_this.constantsLength = 0;
+		_this.compiledFragShaderString = null;
+		_this.compiledVertShaderString = null;
+		_this.fragShader = null;
+		_this.vertShader = null;
+		_this.drawBuffersMap = null;
+		_this.outputTexture = null;
+		_this.maxTexSize = null;
+		_this.uniform1fCache = {};
+		_this.uniform1iCache = {};
+		_this.uniform2fCache = {};
+		_this.uniform2fvCache = {};
+		_this.uniform2ivCache = {};
+		_this.uniform3fvCache = {};
+		_this.uniform3ivCache = {};
+		if (!_this._webGl) _this._webGl = _this.initWebGl();
+		return _this;
+	}
+
+	_createClass(WebGLKernel, [{
+		key: 'initWebGl',
+		value: function initWebGl() {
+			return utils.initWebGl(this.getCanvas());
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name validateOptions
+   *
+   * @desc Validate options related to Kernel, such as
+   * floatOutputs and Textures, texSize, output,
+   * graphical output.
+   *
+   */
+
+	}, {
+		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;
+			}
+
+			var hasIntegerDivisionBug = utils.hasIntegerDivisionAccuracyBug();
+			if (this.fixIntegerDivisionAccuracy === null) {
+				this.fixIntegerDivisionAccuracy = hasIntegerDivisionBug;
+			} else if (this.fixIntegerDivisionAccuracy && !hasIntegerDivisionBug) {
+				this.fixIntegerDivisionAccuracy = false;
+			}
+
+			utils.checkOutput(this.output);
+
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw new Error('Auto output 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 === 'NumberTexture' || argType === 'ArrayTexture(4)') {
+					this.output = arguments[0].output;
+				} else {
+					throw new Error('Auto output not supported for input type: ' + argType);
+				}
+			}
+
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+
+			if (this.graphical) {
+				if (this.output.length !== 2) {
+					throw new Error('Output must have 2 dimensions on graphical mode');
+				}
+
+				if (this.floatOutput) {
+					this.floatOutput = false;
+					console.warn('Cannot use graphical mode and float output at the same time');
+				}
+
+				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];
+			}
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name build
+   *
+   * @desc Builds the Kernel, by compiling Fragment and Vertical Shaders,
+   * and instantiates the program.
+   *
+   */
+
+	}, {
+		key: 'build',
+		value: function build() {
+			this.validateOptions();
+			this.setupConstants();
+			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);
+			}
+
+			if (this.functionBuilder) this._addKernels();
+
+			var compiledVertShaderString = this._getVertShaderString(arguments);
+			var vertShader = gl.createShader(gl.VERTEX_SHADER);
+			gl.shaderSource(vertShader, compiledVertShaderString);
+			gl.compileShader(vertShader);
+			this.vertShader = vertShader;
+
+			var compiledFragShaderString = this._getFragShaderString(arguments);
+			var fragShader = gl.createShader(gl.FRAGMENT_SHADER);
+			gl.shaderSource(fragShader, compiledFragShaderString);
+			gl.compileShader(fragShader);
+			this.fragShader = fragShader;
+
+			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');
+			}
+
+			if (this.debug) {
+				console.log('Options:');
+				console.dir(this);
+				console.log('GLSL Shader Output:');
+				console.log(compiledFragShaderString);
+			}
+
+			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];
+
+			var vertices = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
+			var texCoords = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+
+			var texCoordOffset = vertices.byteLength;
+
+			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);
+			}
+
+			gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
+			gl.bufferSubData(gl.ARRAY_BUFFER, texCoordOffset, texCoords);
+
+			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);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+			for (var p in this.constants) {
+				var value = this.constants[p];
+				var type = utils.getArgumentType(value);
+				if (type === 'Float' || type === 'Integer') {
+					continue;
+				}
+				gl.useProgram(this.program);
+				this._addConstant(this.constants[p], type, p);
+				this.constantsLength++;
+			}
+
+			if (!this.outputImmutable) {
+				this._setupOutputTexture();
+				if (this.subKernelOutputVariableNames !== null && this.subKernelOutputVariableNames.length > 0) {
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+			}
+		}
+
+		/**
+   * @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|Undefined} Result The final output of the program, as float, and as Textures for reuse.
+   *
+   *
+   */
+
+	}, {
+		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) {
+				this.setUniform3iv('uOutputDim', this.threadDim);
+				this.setUniform2iv('uTexSize', texSize);
+			}
+
+			this.setUniform2f('ratio', 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.constrainStart || this.constrainEnd) {
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+				if (this.constrainStart) {} else {}
+				if (this.constrainEnd) {} else {}
+				var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.5, 0.5, 0.0];
+
+				var indices = [3, 2, 1, 3, 1, 0];
+
+				// Create an empty buffer object to store vertex buffer
+				var vertex_buffer = gl.createBuffer();
+
+				// Bind appropriate array buffer to it
+				gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+				// Pass the vertex data to the buffer
+				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+				// Unbind the buffer
+				gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+				// Create an empty buffer object to store Index buffer
+				var Index_Buffer = gl.createBuffer();
+
+				// Bind appropriate array buffer to it
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+				// Pass the vertex data to the buffer
+				gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+				// Unbind the buffer
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+				// original
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLES, 0, 6);
+				this._setupOutputTexture();
+				return this.renderOutput(this.outputTexture);
+			}
+
+			if (this.graphical) {
+				if (this.outputToTexture) {
+					gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+					gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+					if (!this.outputTexture || this.outputImmutable) {
+						this._setupOutputTexture();
+					}
+					gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+					return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this._webGl, 'ArrayTexture(4)');
+				}
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+				return;
+			}
+
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+			if (this.outputImmutable) {
+				this._setupOutputTexture();
+			}
+			var outputTexture = this.outputTexture;
+
+			if (this.subKernelOutputVariableNames !== null) {
+				if (this.outputImmutable) {
+					this.subKernelOutputTextures = [];
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+				this.drawBuffers.drawBuffersWEBGL(this.drawBuffersMap);
+			}
+
+			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.threadDim, this.output, this._webGl));
+					}
+					return output;
+				} else if (this.subKernelProperties !== null) {
+					var _output = {
+						result: this.renderOutput(outputTexture)
+					};
+					var _i = 0;
+					for (var p in this.subKernelProperties) {
+						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+						_output[p] = new Texture(this.subKernelOutputTextures[_i], texSize, this.threadDim, this.output, this._webGl);
+						_i++;
+					}
+					return _output;
+				}
+			}
+
+			return this.renderOutput(outputTexture);
+		}
+
+		/**
+   * @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
+   *
+   *
+   */
+
+	}, {
+		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, this.threadDim, output, this._webGl);
+			} else {
+				var result = void 0;
+				if (this.floatOutput) {
+					var w = texSize[0];
+					var h = Math.ceil(texSize[1] / 4);
+					result = new Float32Array(w * h * 4);
+					gl.readPixels(0, 0, w, h, 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);
+				}
+
+				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]);
+					});
+				}
+			}
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name getOutputTexture
+   *
+   * @desc This return defined outputTexture, which is setup in .build(), or if immutable, is defined in .run()
+   *
+   * @returns {Object} Output Texture Cache
+   *
+   */
+
+	}, {
+		key: 'getOutputTexture',
+		value: function getOutputTexture() {
+			return this.outputTexture;
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _setupOutputTexture
+   * @private
+   *
+   * @desc Setup and replace output texture
+   */
+
+	}, {
+		key: '_setupOutputTexture',
+		value: function _setupOutputTexture() {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var texture = this.outputTexture = this._webGl.createTexture();
+			gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length);
+			gl.bindTexture(gl.TEXTURE_2D, texture);
+			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);
+			}
+			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @param length
+   * @private
+   *
+   * @desc Setup and replace sub-output textures
+   */
+
+	}, {
+		key: '_setupSubOutputTextures',
+		value: function _setupSubOutputTextures(length) {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
+			var textures = this.subKernelOutputTextures = [];
+			for (var i = 0; i < length; i++) {
+				var texture = this._webGl.createTexture();
+				textures.push(texture);
+				drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
+				gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length + i);
+				gl.bindTexture(gl.TEXTURE_2D, texture);
+				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);
+				}
+				gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
+			}
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'getArgumentTexture',
+		value: function getArgumentTexture(name) {
+			return this.getTextureCache('ARGUMENT_' + name);
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'getTextureCache',
+		value: function getTextureCache(name) {
+			if (this.textureCache.hasOwnProperty(name)) {
+				return this.textureCache[name];
+			}
+			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
+   */
+
+	}, {
+		key: 'detachTextureCache',
+		value: function detachTextureCache(name) {
+			delete this.textureCache[name];
+		}
+	}, {
+		key: 'setUniform1f',
+		value: function setUniform1f(name, value) {
+			if (this.uniform1fCache.hasOwnProperty(name)) {
+				var cache = this.uniform1fCache[name];
+				if (value === cache) {
+					return;
+				}
+			}
+			this.uniform1fCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform1f(loc, value);
+		}
+	}, {
+		key: 'setUniform1i',
+		value: function setUniform1i(name, value) {
+			if (this.uniform1iCache.hasOwnProperty(name)) {
+				var cache = this.uniform1iCache[name];
+				if (value === cache) {
+					return;
+				}
+			}
+			this.uniform1iCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform1i(loc, value);
+		}
+	}, {
+		key: 'setUniform2f',
+		value: function setUniform2f(name, value1, value2) {
+			if (this.uniform2fCache.hasOwnProperty(name)) {
+				var cache = this.uniform2fCache[name];
+				if (value1 === cache[0] && value2 === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2fCache[name] = [value1, value2];
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2f(loc, value1, value2);
+		}
+	}, {
+		key: 'setUniform2fv',
+		value: function setUniform2fv(name, value) {
+			if (this.uniform2fvCache.hasOwnProperty(name)) {
+				var cache = this.uniform2fvCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2fvCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2fv(loc, value);
+		}
+	}, {
+		key: 'setUniform2iv',
+		value: function setUniform2iv(name, value) {
+			if (this.uniform2ivCache.hasOwnProperty(name)) {
+				var cache = this.uniform2ivCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1]) {
+					return;
+				}
+			}
+			this.uniform2ivCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform2iv(loc, value);
+		}
+	}, {
+		key: 'setUniform3fv',
+		value: function setUniform3fv(name, value) {
+			if (this.uniform3fvCache.hasOwnProperty(name)) {
+				var cache = this.uniform3fvCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1] && value[2] === cache[2]) {
+					return;
+				}
+			}
+			this.uniform3fvCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform3fv(loc, value);
+		}
+	}, {
+		key: 'setUniform3iv',
+		value: function setUniform3iv(name, value) {
+			if (this.uniform3ivCache.hasOwnProperty(name)) {
+				var cache = this.uniform3ivCache[name];
+				if (value[0] === cache[0] && value[1] === cache[1] && value[2] === cache[2]) {
+					return;
+				}
+			}
+			this.uniform3ivCache[name] = value;
+			var loc = this.getUniformLocation(name);
+			this._webGl.uniform3iv(loc, value);
+		}
+
+		/**
+   * @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.
+   *
+   */
+
+	}, {
+		key: 'getUniformLocation',
+		value: function getUniformLocation(name) {
+			if (this.programUniformLocationCache.hasOwnProperty(name)) {
+				return this.programUniformLocationCache[name];
+			}
+			return this.programUniformLocationCache[name] = this._webGl.getUniformLocation(this.program, name);
+		}
+
+		/**
+   * @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.)
+   *
+   */
+
+	}, {
+		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(),
+				DIVIDE_WITH_INTEGER_CHECK: this._getDivideWithIntegerCheckString(),
+				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()
+			};
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: '_addArgument',
+		value: function _addArgument(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			switch (type) {
+				case 'Array':
+				case 'Array(2)':
+				case 'Array(3)':
+				case 'Array(4)':
+				case 'Array2D':
+				case 'Array3D':
+					{
+						var dim = utils.getDimensions(value, true);
+						var size = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, dim);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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 _formatArrayTransfer2 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer2.valuesFlat,
+						    bitRatio = _formatArrayTransfer2.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', dim);
+							this.setUniform2iv('user_' + name + 'Size', size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				case 'Number':
+					{
+						this.setUniform1f('user_' + name, 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.constantsLength + 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 _formatArrayTransfer3 = this._formatArrayTransfer(value.value, _length),
+						    _valuesFlat = _formatArrayTransfer3.valuesFlat,
+						    _bitRatio = _formatArrayTransfer3.bitRatio;
+
+						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(_valuesFlat.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0] / _bitRatio, _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', _dim);
+							this.setUniform2iv('user_' + name + 'Size', _size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', _bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim2 = [inputImage.width, inputImage.height, 1];
+						var _size2 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the image into the texture.
+						var mipLevel = 0; // the largest mip
+						var internalFormat = gl.RGBA; // format we want in the texture
+						var srcFormat = gl.RGBA; // format of data we are supplying
+						var srcType = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('user_' + name + 'Dim', _dim2);
+						this.setUniform2iv('user_' + name + 'Size', _size2);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim3 = inputTexture.dimensions;
+						var _size3 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('user_' + name + 'Dim', _dim3);
+						this.setUniform2iv('user_' + name + 'Size', _size3);
+						this.setUniform1i('user_' + name + 'BitRatio', 1); // aways float32
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+			this.argumentsLength++;
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _addConstant
+   *
+   * @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
+   *
+   */
+
+	}, {
+		key: '_addConstant',
+		value: function _addConstant(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength);
+						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 _formatArrayTransfer4 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer4.valuesFlat,
+						    bitRatio = _formatArrayTransfer4.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', dim);
+							this.setUniform2iv('constants_' + name + 'Size', size);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Input':
+					{
+						var input = value;
+						var _dim4 = input.size;
+						var _size4 = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, _dim4);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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 _length2 = _size4[0] * _size4[1];
+
+						var _formatArrayTransfer5 = this._formatArrayTransfer(value.value, _length2),
+						    _valuesFlat2 = _formatArrayTransfer5.valuesFlat,
+						    _bitRatio2 = _formatArrayTransfer5.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size4[0], _size4[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer2 = new Uint8Array(_valuesFlat2.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size4[0] / _bitRatio2, _size4[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer2);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', _dim4);
+							this.setUniform2iv('constants_' + name + 'Size', _size4);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', _bitRatio2);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim5 = [inputImage.width, inputImage.height, 1];
+						var _size5 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the image into the texture.
+						var mipLevel = 0; // the largest mip
+						var internalFormat = gl.RGBA; // format we want in the texture
+						var srcFormat = gl.RGBA; // format of data we are supplying
+						var srcType = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('constants_' + name + 'Dim', _dim5);
+						this.setUniform2iv('constants_' + name + 'Size', _size5);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim6 = inputTexture.dimensions;
+						var _size6 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('constants_' + name + 'Dim', _dim6);
+						this.setUniform2iv('constants_' + name + 'Size', _size6);
+						this.setUniform1i('constants_' + name + 'BitRatio', 1); // aways float32
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _formatArrayTransfer
+   *
+   * @desc Adds kernel parameters to the Argument Texture,
+   * binding it to the webGl instance, etc.
+   *
+   * @param {Array} value - The actual argument supplied to the kernel
+   * @param {String} length - the expected total length of the output array
+   *
+   * @returns {Object} bitRatio - bit storage ratio of source to target 'buffer', i.e. if 8bit array -> 32bit tex = 4
+   * 				     valuesFlat - flattened array to transfer
+   */
+
+	}, {
+		key: '_formatArrayTransfer',
+		value: function _formatArrayTransfer(value, length) {
+			var bitRatio = 1; // bit storage ratio of source to target 'buffer', i.e. if 8bit array -> 32bit tex = 4
+			var valuesFlat = value;
+			if (utils.isArray(value[0]) || this.floatTextures) {
+				// not already flat
+				valuesFlat = new Float32Array(length);
+				utils.flattenTo(value, valuesFlat);
+			} else {
+
+				switch (value.constructor) {
+					case Uint8Array:
+					case Int8Array:
+						bitRatio = 4;
+						break;
+					case Uint16Array:
+					case Int16Array:
+						bitRatio = 2;
+					case Float32Array:
+					case Int32Array:
+						break;
+
+					default:
+						valuesFlat = new Float32Array(length);
+						utils.flattenTo(value, valuesFlat);
+				}
+			}
+			return {
+				bitRatio: bitRatio,
+				valuesFlat: valuesFlat
+			};
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getHeaderString',
+		value: function _getHeaderString() {
+			return this.subKernels !== null || this.subKernelProperties !== null ?
+			//webgl2 '#version 300 es\n' :
+			'#extension GL_EXT_draw_buffers : require\n' : '';
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getLoopMaxString
+   *
+   * @desc Get the maximum loop size String.
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getLoopMaxString',
+		value: function _getLoopMaxString() {
+			return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + '.0;\n' : ' 1000.0;\n';
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getConstantsString',
+		value: function _getConstantsString() {
+			var result = [];
+			var threadDim = this.threadDim;
+			var texSize = this.texSize;
+			if (this.hardcodeConstants) {
+				result.push('ivec3 uOutputDim = ivec3(' + threadDim[0] + ',' + threadDim[1] + ', ' + threadDim[2] + ')', 'ivec2 uTexSize = ivec2(' + texSize[0] + ', ' + texSize[1] + ')');
+			} else {
+				result.push('uniform ivec3 uOutputDim', 'uniform ivec2 uTexSize');
+			}
+
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getTextureCoordinate
+   *
+   * @desc Get texture coordinate string for the program
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getTextureCoordinate',
+		value: function _getTextureCoordinate() {
+			var names = this.subKernelOutputVariableNames;
+			if (names === null || names.length < 1) {
+				return 'varying vec2 vTexCoord;\n';
+			} else {
+				return 'out vec2 vTexCoord;\n';
+			}
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getDecode32EndiannessString
+   *
+   * @desc Get Decode32 endianness string for little-endian and big-endian
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getDecode32EndiannessString',
+		value: function _getDecode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getEncode32EndiannessString
+   *
+   * @desc Get Encode32 endianness string for little-endian and big-endian
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getEncode32EndiannessString',
+		value: function _getEncode32EndiannessString() {
+			return this.endianness === 'LE' ? '' : '  rgba.rgba = rgba.abgr;\n';
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getDivideWithIntegerCheckString
+   *
+   * @desc if fixIntegerDivisionAccuracy provide method to replace /
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getDivideWithIntegerCheckString',
+		value: function _getDivideWithIntegerCheckString() {
+			return this.fixIntegerDivisionAccuracy ? '\n\t\t\t  float div_with_int_check(float x, float y) {\n\t\t\t  if (floor(x) == x && floor(y) == y && integerMod(x, y) == 0.0) {\n\t\t\t    return float(int(x)/int(y));\n\t\t\t  }\n\t\t\t  return x / y;\n\t\t\t}\n\t\t\t' : '';
+		}
+
+		/**
+   * @function
+   * @memberOf WebGLKernel#
+   * @name _getGetWraparoundString
+   *
+   * @returns {String} wraparound string
+   */
+
+	}, {
+		key: '_getGetWraparoundString',
+		value: function _getGetWraparoundString() {
+			return this.wraparound ? '  xyz = mod(xyz, texDim);\n' : '';
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetTextureChannelString
+   *
+   */
+
+	}, {
+		key: '_getGetTextureChannelString',
+		value: function _getGetTextureChannelString() {
+			if (!this.floatTextures) return '';
+
+			return this._linesToString(['  int channel = integerMod(index, 4)', '  index = index / 4']);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetTextureIndexString
+   *
+   * @desc Get generic texture index string, if floatTextures flag is true.
+   *
+   * @example
+   * '  index = float(int(index)/4);\n'
+   *
+   */
+
+	}, {
+		key: '_getGetTextureIndexString',
+		value: function _getGetTextureIndexString() {
+			return this.floatTextures ? '  index = index / 4;\n' : '';
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getGetResultString
+   *
+   */
+
+	}, {
+		key: '_getGetResultString',
+		value: function _getGetResultString() {
+			if (!this.floatTextures) {
+				return '  return decode(texel, x, bitRatio);';
+			}
+			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']);
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		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 === 'NumberTexture' || paramType === 'ArrayTexture(4)') {
+						var paramDim = utils.getDimensions(param, true);
+						var paramSize = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, paramDim);
+
+						result.push('uniform sampler2D user_' + paramName, 'ivec2 user_' + paramName + 'Size = ivec2(' + paramSize[0] + ', ' + paramSize[1] + ')', 'ivec3 user_' + paramName + 'Dim = ivec3(' + paramDim[0] + ', ' + paramDim[1] + ', ' + paramDim[2] + ')', 'uniform int user_' + paramName + 'BitRatio');
+					} else if (paramType === 'Integer') {
+						result.push('float user_' + paramName + ' = ' + param + '.0');
+					} else if (paramType === 'Float') {
+						result.push('float user_' + paramName + ' = ' + param);
+					}
+				} else {
+					if (paramType === 'Array' || paramType === 'NumberTexture' || paramType === 'ArrayTexture(4)' || paramType === 'Input' || paramType === 'HTMLImage') {
+						result.push('uniform sampler2D user_' + paramName, 'uniform ivec2 user_' + paramName + 'Size', 'uniform ivec3 user_' + paramName + 'Dim');
+						if (paramType !== 'HTMLImage') {
+							result.push('uniform int user_' + paramName + 'BitRatio');
+						}
+					} else if (paramType === 'Integer' || paramType === 'Float') {
+						result.push('uniform float user_' + paramName);
+					} else {
+						throw new Error('Param type ' + paramType + ' not supported in WebGL, only WebGL2');
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainConstantsString
+   *
+   */
+
+	}, {
+		key: '_getMainConstantsString',
+		value: function _getMainConstantsString() {
+			var result = [];
+			if (this.constants) {
+				for (var name in this.constants) {
+					if (!this.constants.hasOwnProperty(name)) continue;
+					var value = this.constants[name];
+					var type = utils.getArgumentType(value);
+					switch (type) {
+						case 'Integer':
+							result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
+							break;
+						case 'Float':
+							result.push('const float constants_' + name + ' = ' + parseFloat(value));
+							break;
+						case 'Array':
+						case 'Input':
+						case 'HTMLImage':
+						case 'NumberTexture':
+						case 'ArrayTexture(4)':
+							result.push('uniform sampler2D constants_' + name, 'uniform ivec2 constants_' + name + 'Size', 'uniform ivec3 constants_' + name + 'Dim', 'uniform int constants_' + name + 'BitRatio');
+							break;
+						default:
+							throw new Error('Unsupported constant ' + name + ' type ' + type);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getKernelString
+   *
+   * @desc Get Kernel program string (in *glsl*) for a kernel.
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getKernelString',
+		value: function _getKernelString() {
+			var result = [];
+			var names = this.subKernelOutputVariableNames;
+			if (names !== null) {
+				result.push('float kernelResult = 0.0');
+				for (var i = 0; i < names.length; i++) {
+					result.push('float ' + names[i] + ' = 0.0');
+				}
+			} else {
+				result.push('float kernelResult = 0.0');
+			}
+
+			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+		}
+
+		/**
+   *
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainResultString
+   *
+   * @desc Get main result string with checks for floatOutput, graphical, subKernelsOutputs, etc.
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getMainResultString',
+		value: function _getMainResultString() {
+			var names = this.subKernelOutputVariableNames;
+			var result = [];
+
+			if (this.floatOutput) {
+				result.push('  index *= 4');
+			}
+
+			if (this.graphical) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = actualColor');
+			} else if (this.floatOutput) {
+				var channels = ['r', 'g', 'b', 'a'];
+
+				for (var i = 0; i < channels.length; ++i) {
+					result.push('  threadId = indexTo3D(index, uOutputDim)');
+					result.push('  kernel()');
+
+					if (names) {
+						result.push('  gl_FragData[0].' + channels[i] + ' = kernelResult');
+
+						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');
+					}
+
+					if (i < channels.length - 1) {
+						result.push('  index += 1');
+					}
+				}
+			} else if (names !== null) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)');
+				result.push('  kernel()');
+				result.push('  gl_FragData[0] = encode32(kernelResult)');
+				for (var _i2 = 0; _i2 < names.length; _i2++) {
+					result.push('  gl_FragData[' + (_i2 + 1) + '] = encode32(' + names[_i2] + ')');
+				}
+			} else {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  gl_FragColor = encode32(kernelResult)');
+			}
+
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _linesToString
+   *
+   * @param {Array} lines - An Array of strings
+   *
+   * @returns {String} Single combined String, seperated by *\n*
+   *
+   */
+
+	}, {
+		key: '_linesToString',
+		value: function _linesToString(lines) {
+			if (lines.length > 0) {
+				return lines.join(';\n') + ';\n';
+			} else {
+				return '\n';
+			}
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _replaceArtifacts
+   *
+   * @param {String} src - Shader string
+   * @param {Array} map - Variables/Constants associated with shader
+   *
+   */
+
+	}, {
+		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;
+			});
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _addKernels
+   *
+   * @desc Adds all the sub-kernels supplied with this Kernel instance.
+   *
+   */
+
+	}, {
+		key: '_addKernels',
+		value: function _addKernels() {
+			var _this2 = this;
+
+			var builder = this.functionBuilder;
+			var gl = this._webGl;
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+			builder.addNativeFunctions(this.nativeFunctions);
+
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				paramNames: this.paramNames,
+				paramTypes: this.paramTypes,
+				constantTypes: this.constantTypes,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+
+			if (this.subKernels !== null) {
+				var drawBuffers = this.drawBuffers = gl.getExtension('WEBGL_draw_buffers');
+				if (!drawBuffers) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputVariableNames = [];
+				this.subKernels.forEach(function (subKernel) {
+					return _this2._addSubKernel(subKernel);
+				});
+			} else if (this.subKernelProperties !== null) {
+				var _drawBuffers = this.drawBuffers = gl.getExtension('WEBGL_draw_buffers');
+				if (!_drawBuffers) throw new Error('could not instantiate draw buffers extension');
+				this.subKernelOutputVariableNames = [];
+				Object.keys(this.subKernelProperties).forEach(function (property) {
+					return _this2._addSubKernel(_this2.subKernelProperties[property]);
+				});
+			}
+		}
+	}, {
+		key: '_addSubKernel',
+		value: function _addSubKernel(subKernel) {
+			this.functionBuilder.addSubKernel(subKernel, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+			this.subKernelOutputVariableNames.push(subKernel.name + 'Result');
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getFragShaderString',
+		value: function _getFragShaderString(args) {
+			if (this.compiledFragShaderString !== null) {
+				return this.compiledFragShaderString;
+			}
+			return this.compiledFragShaderString = this._replaceArtifacts(this.constructor.fragShaderString, this._getFragShaderArtifactMap(args));
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getVertShaderString',
+		value: function _getVertShaderString(args) {
+			if (this.compiledVertShaderString !== null) {
+				return this.compiledVertShaderString;
+			}
+			return this.compiledVertShaderString = this.constructor.vertShaderString;
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name toString
+   *
+   * @desc Returns the *pre-compiled* Kernel as a JS Object String, that can be reused.
+   *
+   */
+
+	}, {
+		key: 'toString',
+		value: function toString() {
+			return kernelString(this);
+		}
+	}, {
+		key: 'addFunction',
+		value: function addFunction(fn) {
+			this.functionBuilder.addFunction(null, fn);
+		}
+	}, {
+		key: 'destroy',
+		value: function destroy(removeCanvasReferences) {
+			_get(WebGLKernel.prototype.__proto__ || Object.getPrototypeOf(WebGLKernel.prototype), 'destroy', this).call(this);
+			if (this.outputTexture) {
+				this._webGl.deleteTexture(this.outputTexture);
+			}
+			if (this.buffer) {
+				this._webGl.deleteBuffer(this.buffer);
+			}
+			if (this.framebuffer) {
+				this._webGl.deleteFramebuffer(this.framebuffer);
+			}
+
+			if (this.vertShader) {
+				this._webGl.deleteShader(this.vertShader);
+			}
+
+			if (this.fragShader) {
+				this._webGl.deleteShader(this.fragShader);
+			}
+
+			if (this.program) {
+				this._webGl.deleteProgram(this.program);
+			}
+
+			var keys = Object.keys(this.textureCache);
+
+			for (var i = 0; i < keys.length; i++) {
+				var name = keys[i];
+				this._webGl.deleteTexture(this.textureCache[name]);
+			}
+
+			if (this.subKernelOutputTextures) {
+				for (var _i3 = 0; _i3 < this.subKernelOutputTextures.length; _i3++) {
+					this._webGl.deleteTexture(this.subKernelOutputTextures[_i3]);
+				}
+			}
+			if (removeCanvasReferences) {
+				var idx = canvases.indexOf(this._canvas);
+				if (idx >= 0) {
+					canvases[idx] = null;
+					maxTexSizes[idx] = null;
+				}
+			}
+			delete this._webGl;
+		}
+	}]);
+
+	return WebGLKernel;
+}(KernelBase);
\ No newline at end of file
diff --git a/dist/backend/web-gl/runner.js b/dist/backend/web-gl/runner.js
new file mode 100644
index 00000000..f1672c72
--- /dev/null
+++ b/dist/backend/web-gl/runner.js
@@ -0,0 +1,58 @@
+'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"); } }
+
+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 RunnerBase = require('../runner-base');
+var WebGLKernel = require('./kernel');
+var WebGLFunctionBuilder = require('./function-builder');
+
+module.exports = function (_RunnerBase) {
+	_inherits(WebGLRunner, _RunnerBase);
+
+	/**
+  * @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 _this = _possibleConstructorReturn(this, (WebGLRunner.__proto__ || Object.getPrototypeOf(WebGLRunner)).call(this, new WebGLFunctionBuilder(), settings));
+
+		_this.Kernel = WebGLKernel;
+		_this.kernel = null;
+		return _this;
+	}
+
+	/**
+  * @memberOf WebGLRunner#
+  * @function
+  * @name getMode
+  *
+  * @desc Return the current mode in which gpu.js is executing.
+  * 
+  * @returns {String} The current mode; "cpu".
+  *
+  */
+
+
+	_createClass(WebGLRunner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'gpu';
+		}
+	}]);
+
+	return WebGLRunner;
+}(RunnerBase);
\ No newline at end of file
diff --git a/dist/backend/web-gl2/kernel.js b/dist/backend/web-gl2/kernel.js
new file mode 100644
index 00000000..0065bb78
--- /dev/null
+++ b/dist/backend/web-gl2/kernel.js
@@ -0,0 +1,1024 @@
+'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"); } }
+
+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 WebGLKernel = require('../web-gl/kernel');
+var utils = require('../../core/utils');
+var Texture = require('../../core/texture');
+var fragShaderString = require('./shader-frag');
+var vertShaderString = require('./shader-vert');
+
+module.exports = function (_WebGLKernel) {
+	_inherits(WebGL2Kernel, _WebGLKernel);
+
+	function WebGL2Kernel() {
+		_classCallCheck(this, WebGL2Kernel);
+
+		return _possibleConstructorReturn(this, (WebGL2Kernel.__proto__ || Object.getPrototypeOf(WebGL2Kernel)).apply(this, arguments));
+	}
+
+	_createClass(WebGL2Kernel, [{
+		key: 'initWebGl',
+		value: function initWebGl() {
+			return utils.initWebGl2(this.getCanvas());
+		}
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name validateOptions
+   *
+   * @desc Validate options related to Kernel, such as
+   * floatOutputs and Textures, texSize, output,
+   * graphical output.
+   *
+   */
+
+	}, {
+		key: 'validateOptions',
+		value: function validateOptions() {
+			var isFloatReadPixel = utils.isFloatReadPixelsSupportedWebGL2();
+			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) {
+				this.floatTextures = true;
+				this.floatOutput = isFloatReadPixel;
+			}
+
+			var hasIntegerDivisionBug = utils.hasIntegerDivisionAccuracyBug();
+			if (this.fixIntegerDivisionAccuracy === null) {
+				this.fixIntegerDivisionAccuracy = hasIntegerDivisionBug;
+			} else if (this.fixIntegerDivisionAccuracy && !hasIntegerDivisionBug) {
+				this.fixIntegerDivisionAccuracy = false;
+			}
+
+			utils.checkOutput(this.output);
+
+			if (!this.output || this.output.length === 0) {
+				if (arguments.length !== 1) {
+					throw new Error('Auto output 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 === 'NumberTexture' || argType === 'ArrayTexture(4)') {
+					this.output = arguments[0].output;
+				} else {
+					throw new Error('Auto output not supported for input type: ' + argType);
+				}
+			}
+
+			this.texSize = utils.dimToTexSize({
+				floatTextures: this.floatTextures,
+				floatOutput: this.floatOutput
+			}, this.output, true);
+
+			if (this.graphical) {
+				if (this.output.length !== 2) {
+					throw new Error('Output must have 2 dimensions on graphical mode');
+				}
+
+				if (this.floatOutput) {
+					this.floatOutput = false;
+					console.warn('Cannot use graphical mode and float output at the same time');
+				}
+
+				this.texSize = utils.clone(this.output);
+			} else if (this.floatOutput === undefined) {
+				this.floatOutput = true;
+			}
+
+			if (this.floatOutput || this.floatOutputForce) {
+				this._webGl.getExtension('EXT_color_buffer_float');
+			}
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @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|Undefined} Result The final output of the program, as float, and as Textures for reuse.
+   *
+   *
+   */
+
+	}, {
+		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) {
+				this.setUniform3iv('uOutputDim', new Int32Array(this.threadDim));
+				this.setUniform2iv('uTexSize', texSize);
+			}
+
+			this.setUniform2f('ratio', 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.constrainStart || this.constrainEnd) {
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+				if (this.constrainStart) {} else {}
+				if (this.constrainEnd) {} else {}
+				var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.5, 0.5, 0.0];
+
+				var indices = [3, 2, 1, 3, 1, 0];
+
+				// Create an empty buffer object to store vertex buffer
+				var vertex_buffer = gl.createBuffer();
+
+				// Bind appropriate array buffer to it
+				gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+				// Pass the vertex data to the buffer
+				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+				// Unbind the buffer
+				gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+				// Create an empty buffer object to store Index buffer
+				var Index_Buffer = gl.createBuffer();
+
+				// Bind appropriate array buffer to it
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+				// Pass the vertex data to the buffer
+				gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+				// Unbind the buffer
+				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+				// original
+
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLES, 0, 6);
+				return;
+			}
+
+			if (this.graphical) {
+				if (this.outputToTexture) {
+					gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+					gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+					if (!this.outputTexture || this.outputImmutable) {
+						this._setupOutputTexture();
+					}
+					gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+					return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this._webGl, 'ArrayTexture(4)');
+				}
+				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+				gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+				return;
+			}
+
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+			if (this.outputImmutable) {
+				this._setupOutputTexture();
+			}
+			var outputTexture = this.outputTexture;
+
+			if (this.subKernelOutputVariableNames !== null) {
+				if (this.outputImmutable) {
+					this.subKernelOutputTextures = [];
+					this._setupSubOutputTextures(this.subKernelOutputVariableNames.length);
+				}
+				gl.drawBuffers(this.drawBuffersMap);
+			}
+
+			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.threadDim, this.output, this._webGl));
+					}
+					return output;
+				} else if (this.subKernelProperties !== null) {
+					var _output = {
+						result: this.renderOutput(outputTexture)
+					};
+					var _i = 0;
+					for (var p in this.subKernelProperties) {
+						if (!this.subKernelProperties.hasOwnProperty(p)) continue;
+						_output[p] = new Texture(this.subKernelOutputTextures[_i], texSize, this.threadDim, this.output, this._webGl);
+						_i++;
+					}
+					return _output;
+				}
+			}
+
+			return this.renderOutput(outputTexture);
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name getOutputTexture
+   *
+   * @desc This return defined outputTexture, which is setup in .build(), or if immutable, is defined in .run()
+   *
+   * @returns {Object} Output Texture Cache
+   *
+   */
+
+	}, {
+		key: 'getOutputTexture',
+		value: function getOutputTexture() {
+			return this.outputTexture;
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _setupOutputTexture
+   * @private
+   *
+   * @desc Setup and replace output texture
+   */
+
+	}, {
+		key: '_setupOutputTexture',
+		value: function _setupOutputTexture() {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var texture = this.outputTexture = this._webGl.createTexture();
+			gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length);
+			gl.bindTexture(gl.TEXTURE_2D, texture);
+			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.RGBA32F, 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);
+			}
+			gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @param length
+   * @private
+   *
+   * @desc Setup and replace sub-output textures
+   */
+
+	}, {
+		key: '_setupSubOutputTextures',
+		value: function _setupSubOutputTextures(length) {
+			var gl = this._webGl;
+			var texSize = this.texSize;
+			var drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
+			var textures = this.subKernelOutputTextures = [];
+			for (var i = 0; i < length; i++) {
+				var texture = this._webGl.createTexture();
+				textures.push(texture);
+				drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
+				gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.paramNames.length + i);
+				gl.bindTexture(gl.TEXTURE_2D, texture);
+				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.RGBA32F, 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);
+				}
+				gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
+			}
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @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
+   *
+   */
+
+	}, {
+		key: '_addArgument',
+		value: function _addArgument(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength + 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 _formatArrayTransfer = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer.valuesFlat,
+						    bitRatio = _formatArrayTransfer.bitRatio;
+
+						var buffer = void 0;
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, 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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', dim);
+							this.setUniform2iv('user_' + name + 'Size', size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				case 'Number':
+					{
+						this.setUniform1f('user_' + name, 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.constantsLength + 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 _formatArrayTransfer2 = this._formatArrayTransfer(value.value, _length),
+						    _valuesFlat = _formatArrayTransfer2.valuesFlat,
+						    _bitRatio = _formatArrayTransfer2.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, _size[0], _size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer = new Uint8Array(_valuesFlat.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size[0] / _bitRatio, _size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('user_' + name + 'Dim', _dim);
+							this.setUniform2iv('user_' + name + 'Size', _size);
+						}
+						this.setUniform1i('user_' + name + 'BitRatio', _bitRatio);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim2 = [inputImage.width, inputImage.height, 1];
+						var _size2 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + 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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the image into the texture.
+						var mipLevel = 0; // the largest mip
+						var internalFormat = gl.RGBA; // format we want in the texture
+						var srcFormat = gl.RGBA; // format of data we are supplying
+						var srcType = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('user_' + name + 'Dim', _dim2);
+						this.setUniform2iv('user_' + name + 'Size', _size2);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'HTMLImageArray':
+					{
+						var inputImages = value;
+						var _dim3 = [inputImages[0].width, inputImages[0].height, inputImages.length];
+						var _size3 = [inputImages[0].width, inputImages[0].height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the images into the texture.
+						var _mipLevel = 0; // the largest mip
+						var _internalFormat = gl.RGBA; // format we want in the texture
+						var width = inputImages[0].width;
+						var height = inputImages[0].height;
+						var textureDepth = inputImages.length;
+						var border = 0;
+						var _srcFormat = gl.RGBA; // format of data we are supplying
+						var _srcType = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel, _internalFormat, width, height, textureDepth, border, _srcFormat, _srcType, null);
+						for (var i = 0; i < inputImages.length; i++) {
+							var xOffset = 0;
+							var yOffset = 0;
+							var imageDepth = 1;
+							gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel, xOffset, yOffset, i, inputImages[i].width, inputImages[i].height, imageDepth, _srcFormat, _srcType, inputImages[i]);
+						}
+						this.setUniform3iv('user_' + name + 'Dim', _dim3);
+						this.setUniform2iv('user_' + name + 'Size', _size3);
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim4 = inputTexture.dimensions;
+						var _size4 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('user_' + name + 'Dim', _dim4);
+						this.setUniform2iv('user_' + name + 'Size', _size4);
+						this.setUniform1i('user_' + name + 'BitRatio', 1); // always float32
+						this.setUniform1i('user_' + name, this.argumentsLength);
+						break;
+					}
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+			this.argumentsLength++;
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _getMainConstantsString
+   *
+   */
+
+	}, {
+		key: '_getMainConstantsString',
+		value: function _getMainConstantsString() {
+			var result = [];
+			if (this.constants) {
+				for (var name in this.constants) {
+					if (!this.constants.hasOwnProperty(name)) continue;
+					var value = this.constants[name];
+					var type = utils.getArgumentType(value);
+					switch (type) {
+						case 'Integer':
+							result.push('const float constants_' + name + ' = ' + parseInt(value) + '.0');
+							break;
+						case 'Float':
+							result.push('const float constants_' + name + ' = ' + parseFloat(value));
+							break;
+						case 'Array':
+						case 'Input':
+						case 'HTMLImage':
+						case 'ArrayTexture(4)':
+						case 'NumberTexture':
+							result.push('uniform highp sampler2D constants_' + name, 'uniform highp ivec2 constants_' + name + 'Size', 'uniform highp ivec3 constants_' + name + 'Dim', 'uniform highp int constants_' + name + 'BitRatio');
+							break;
+						case 'HTMLImageArray':
+							result.push('uniform highp sampler2DArray constants_' + name, 'uniform highp ivec2 constants_' + name + 'Size', 'uniform highp ivec3 constants_' + name + 'Dim', 'uniform highp int constants_' + name + 'BitRatio');
+							break;
+
+						default:
+							throw new Error('Unsupported constant ' + name + ' type ' + type);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGLKernel#
+   * @function
+   * @name _addConstant
+   *
+   * @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
+   *
+   */
+
+	}, {
+		key: '_addConstant',
+		value: function _addConstant(value, type, name) {
+			var gl = this._webGl;
+			var argumentTexture = this.getArgumentTexture(name);
+			if (value instanceof Texture) {
+				type = value.type;
+			}
+			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.constantsLength);
+						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 _formatArrayTransfer3 = this._formatArrayTransfer(value, length),
+						    valuesFlat = _formatArrayTransfer3.valuesFlat,
+						    bitRatio = _formatArrayTransfer3.bitRatio;
+
+						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] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', dim);
+							this.setUniform2iv('constants_' + name + 'Size', size);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', bitRatio);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Input':
+					{
+						var input = value;
+						var _dim5 = input.size;
+						var _size5 = utils.dimToTexSize({
+							floatTextures: this.floatTextures,
+							floatOutput: this.floatOutput
+						}, _dim5);
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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 _length2 = _size5[0] * _size5[1];
+
+						var _formatArrayTransfer4 = this._formatArrayTransfer(value.value, _length2),
+						    _valuesFlat2 = _formatArrayTransfer4.valuesFlat,
+						    _bitRatio2 = _formatArrayTransfer4.bitRatio;
+
+						if (this.floatTextures) {
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, _size5[0], _size5[1], 0, gl.RGBA, gl.FLOAT, inputArray);
+						} else {
+							var _buffer2 = new Uint8Array(_valuesFlat2.buffer);
+							gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _size5[0] / _bitRatio2, _size5[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, _buffer2);
+						}
+
+						if (!this.hardcodeConstants) {
+							this.setUniform3iv('constants_' + name + 'Dim', _dim5);
+							this.setUniform2iv('constants_' + name + 'Size', _size5);
+						}
+						this.setUniform1i('constants_' + name + 'BitRatio', _bitRatio2);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImage':
+					{
+						var inputImage = value;
+						var _dim6 = [inputImage.width, inputImage.height, 1];
+						var _size6 = [inputImage.width, inputImage.height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						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);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the image into the texture.
+						var mipLevel = 0; // the largest mip
+						var internalFormat = gl.RGBA; // format we want in the texture
+						var srcFormat = gl.RGBA; // format of data we are supplying
+						var srcType = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage2D(gl.TEXTURE_2D, mipLevel, internalFormat, srcFormat, srcType, inputImage);
+						this.setUniform3iv('constants_' + name + 'Dim', _dim6);
+						this.setUniform2iv('constants_' + name + 'Size', _size6);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'HTMLImageArray':
+					{
+						var inputImages = value;
+						var _dim7 = [inputImages[0].width, inputImages[0].height, inputImages.length];
+						var _size7 = [inputImages[0].width, inputImages[0].height];
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+						gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+						gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+						// Upload the images into the texture.
+						var _mipLevel2 = 0; // the largest mip
+						var _internalFormat2 = gl.RGBA; // format we want in the texture
+						var width = inputImages[0].width;
+						var height = inputImages[0].height;
+						var textureDepth = inputImages.length;
+						var border = 0;
+						var _srcFormat2 = gl.RGBA; // format of data we are supplying
+						var _srcType2 = gl.UNSIGNED_BYTE; // type of data we are supplying
+						gl.texImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel2, _internalFormat2, width, height, textureDepth, border, _srcFormat2, _srcType2, null);
+						for (var i = 0; i < inputImages.length; i++) {
+							var xOffset = 0;
+							var yOffset = 0;
+							var imageDepth = 1;
+							gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, _mipLevel2, xOffset, yOffset, i, inputImages[i].width, inputImages[i].height, imageDepth, _srcFormat2, _srcType2, inputImages[i]);
+						}
+						this.setUniform3iv('constants_' + name + 'Dim', _dim7);
+						this.setUniform2iv('constants_' + name + 'Size', _size7);
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'ArrayTexture(4)':
+				case 'NumberTexture':
+					{
+						var inputTexture = value;
+						var _dim8 = inputTexture.dimensions;
+						var _size8 = inputTexture.size;
+
+						gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
+						gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
+
+						this.setUniform3iv('constants_' + name + 'Dim', _dim8);
+						this.setUniform2iv('constants_' + name + 'Size', _size8);
+						this.setUniform1i('constants_' + name + 'BitRatio', 1); // aways float32
+						this.setUniform1i('constants_' + name, this.constantsLength);
+						break;
+					}
+				case 'Integer':
+				case 'Float':
+				default:
+					throw new Error('Input type not supported (WebGL): ' + value);
+			}
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _getGetResultString
+   *
+   */
+
+	}, {
+		key: '_getGetResultString',
+		value: function _getGetResultString() {
+			if (!this.floatTextures) {
+				return '  return decode(texel, x, bitRatio);';
+			}
+			return '  return texel[channel];';
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getHeaderString',
+		value: function _getHeaderString() {
+			return '';
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _getTextureCoordinate
+   *
+   * @desc Get texture coordinate string for the program
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getTextureCoordinate',
+		value: function _getTextureCoordinate() {
+			var names = this.subKernelOutputVariableNames;
+			if (names === null || names.length < 1) {
+				return 'in highp vec2 vTexCoord;\n';
+			} else {
+				return 'out highp vec2 vTexCoord;\n';
+			}
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @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
+   *
+   */
+
+	}, {
+		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 === 'NumberTexture' || paramType === 'ArrayTexture(4)') {
+						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 ivec2 user_' + paramName + 'Size = ivec2(' + paramSize[0] + ', ' + paramSize[1] + ')', 'highp ivec3 user_' + paramName + 'Dim = ivec3(' + paramDim[0] + ', ' + paramDim[1] + ', ' + paramDim[2] + ')', 'uniform highp int user_' + paramName + 'BitRatio');
+					} else if (paramType === 'Integer') {
+						result.push('highp float user_' + paramName + ' = ' + param + '.0');
+					} else if (paramType === 'Float') {
+						result.push('highp float user_' + paramName + ' = ' + param);
+					}
+				} else {
+					if (paramType === 'Array' || paramType === 'NumberTexture' || paramType === 'ArrayTexture(4)' || paramType === 'Input' || paramType === 'HTMLImage') {
+						result.push('uniform highp sampler2D user_' + paramName, 'uniform highp ivec2 user_' + paramName + 'Size', 'uniform highp ivec3 user_' + paramName + 'Dim');
+						if (paramType !== 'HTMLImage') {
+							result.push('uniform highp int user_' + paramName + 'BitRatio');
+						}
+					} else if (paramType === 'HTMLImageArray') {
+						result.push('uniform highp sampler2DArray user_' + paramName, 'uniform highp ivec2 user_' + paramName + 'Size', 'uniform highp ivec3 user_' + paramName + 'Dim');
+					} else if (paramType === 'Integer' || paramType === 'Float') {
+						result.push('uniform float user_' + paramName);
+					}
+				}
+			}
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _getKernelString
+   *
+   * @desc Get Kernel program string (in *glsl*) for a kernel.
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getKernelString',
+		value: function _getKernelString() {
+			var result = [];
+			var names = this.subKernelOutputVariableNames;
+			if (names !== null) {
+				result.push('float kernelResult = 0.0');
+				result.push('layout(location = 0) out vec4 data0');
+				for (var i = 0; i < names.length; i++) {
+					result.push('float ' + names[i] + ' = 0.0', 'layout(location = ' + (i + 1) + ') out vec4 data' + (i + 1));
+				}
+			} else {
+				result.push('out vec4 data0');
+				result.push('float kernelResult = 0.0');
+			}
+
+			return this._linesToString(result) + this.functionBuilder.getPrototypeString('kernel');
+		}
+
+		/**
+   *
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _getMainResultString
+   *
+   * @desc Get main result string with checks for floatOutput, graphical, subKernelsOutputs, etc.
+   *
+   * @returns {String} result
+   *
+   */
+
+	}, {
+		key: '_getMainResultString',
+		value: function _getMainResultString() {
+			var names = this.subKernelOutputVariableNames;
+			var result = [];
+
+			if (this.floatOutput) {
+				result.push('  index *= 4');
+			}
+
+			if (this.graphical) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  data0 = actualColor');
+			} else if (this.floatOutput) {
+				var channels = ['r', 'g', 'b', 'a'];
+
+				for (var i = 0; i < channels.length; ++i) {
+					result.push('  threadId = indexTo3D(index, uOutputDim)');
+					result.push('  kernel()');
+
+					if (names) {
+						result.push('  data0.' + channels[i] + ' = kernelResult');
+
+						for (var j = 0; j < names.length; ++j) {
+							result.push('  data' + (j + 1) + '.' + channels[i] + ' = ' + names[j]);
+						}
+					} else {
+						result.push('  data0.' + channels[i] + ' = kernelResult');
+					}
+
+					if (i < channels.length - 1) {
+						result.push('  index += 1');
+					}
+				}
+			} else if (names !== null) {
+				result.push('  threadId = indexTo3D(index, uOutputDim)');
+				result.push('  kernel()');
+				result.push('  data0 = encode32(kernelResult)');
+				for (var _i2 = 0; _i2 < names.length; _i2++) {
+					result.push('  data' + (_i2 + 1) + ' = encode32(' + names[_i2] + ')');
+				}
+			} else {
+				result.push('  threadId = indexTo3D(index, uOutputDim)', '  kernel()', '  data0 = encode32(kernelResult)');
+			}
+
+			return this._linesToString(result);
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _addKernels
+   *
+   * @desc Adds all the sub-kernels supplied with this Kernel instance.
+   *
+   */
+
+	}, {
+		key: '_addKernels',
+		value: function _addKernels() {
+			var _this2 = this;
+
+			var builder = this.functionBuilder;
+			var gl = this._webGl;
+
+			builder.addFunctions(this.functions, {
+				constants: this.constants,
+				output: this.output
+			});
+			builder.addNativeFunctions(this.nativeFunctions);
+
+			builder.addKernel(this.fnString, {
+				prototypeOnly: false,
+				constants: this.constants,
+				output: this.output,
+				debug: this.debug,
+				loopMaxIterations: this.loopMaxIterations,
+				paramNames: this.paramNames,
+				paramTypes: this.paramTypes,
+				constantTypes: this.constantTypes,
+				fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
+			});
+
+			if (this.subKernels !== null) {
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				this.subKernels.forEach(function (subKernel) {
+					return _this2._addSubKernel(subKernel);
+				});
+			} else if (this.subKernelProperties !== null) {
+				this.subKernelOutputTextures = [];
+				this.subKernelOutputVariableNames = [];
+				Object.keys(this.subKernelProperties).forEach(function (property) {
+					return _this2._addSubKernel(_this2.subKernelProperties[property]);
+				});
+			}
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @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
+   *
+   */
+
+	}, {
+		key: '_getFragShaderString',
+		value: function _getFragShaderString(args) {
+			if (this.compiledFragShaderString !== null) {
+				return this.compiledFragShaderString;
+			}
+			return this.compiledFragShaderString = this._replaceArtifacts(this.constructor.fragShaderString, this._getFragShaderArtifactMap(args));
+		}
+
+		/**
+   * @memberOf WebGL2Kernel#
+   * @function
+   * @name _getVertShaderString
+   *
+   * @desc Get the vertical shader String
+   *
+   * @param {Array} args - The actual parameters sent to the Kernel
+   *
+   * @returns {string} Vertical Shader string
+   *
+   */
+
+	}, {
+		key: '_getVertShaderString',
+		value: function _getVertShaderString(args) {
+			if (this.compiledVertShaderString !== null) {
+				return this.compiledVertShaderString;
+			}
+			return this.compiledVertShaderString = this.constructor.vertShaderString;
+		}
+	}], [{
+		key: 'fragShaderString',
+		get: function get() {
+			return fragShaderString;
+		}
+	}, {
+		key: 'vertShaderString',
+		get: function get() {
+			return vertShaderString;
+		}
+	}]);
+
+	return WebGL2Kernel;
+}(WebGLKernel);
\ No newline at end of file
diff --git a/dist/backend/web-gl2/runner.js b/dist/backend/web-gl2/runner.js
new file mode 100644
index 00000000..8f521351
--- /dev/null
+++ b/dist/backend/web-gl2/runner.js
@@ -0,0 +1,58 @@
+'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"); } }
+
+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 RunnerBase = require('../runner-base');
+var WebGL2FunctionBuilder = require('./function-builder');
+var WebGL2Kernel = require('./kernel');
+
+module.exports = function (_RunnerBase) {
+	_inherits(WebGL2Runner, _RunnerBase);
+
+	/**
+  * @constructor WebGL2Runner
+  *
+  * @extends RunnerBase
+ 
+  * @desc Instantiates a Runner instance for the kernel.
+  *
+  * @param {Object} settings - Settings to instantiate properties in RunnerBase, with given values
+  *
+  */
+	function WebGL2Runner(settings) {
+		_classCallCheck(this, WebGL2Runner);
+
+		var _this = _possibleConstructorReturn(this, (WebGL2Runner.__proto__ || Object.getPrototypeOf(WebGL2Runner)).call(this, new WebGL2FunctionBuilder(), settings));
+
+		_this.Kernel = WebGL2Kernel;
+		_this.kernel = null;
+		return _this;
+	}
+
+	/**
+  * @memberOf WebGL2Runner#
+  * @function
+  * @name getMode
+  *
+  * @desc Return the current mode in which gpu.js is executing.
+  *
+  * @returns {String} The current mode; "gpu".
+  *
+  */
+
+
+	_createClass(WebGL2Runner, [{
+		key: 'getMode',
+		value: function getMode() {
+			return 'gpu';
+		}
+	}]);
+
+	return WebGL2Runner;
+}(RunnerBase);
\ No newline at end of file
diff --git a/dist/core/utils.js b/dist/core/utils.js
new file mode 100644
index 00000000..4d104b1c
--- /dev/null
+++ b/dist/core/utils.js
@@ -0,0 +1,710 @@
+'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 _isFloatReadPixelsSupportedWebGL2 = null;
+
+var _isMixedIdentifiersSupported = function () {
+	try {
+		new Function('let i = 1; const j = 1;')();
+		return true;
+	} catch (e) {
+		return false;
+	}
+}();
+
+var _hasIntegerDivisionAccuracyBug = null;
+
+/**
+ * @class
+ * @extends UtilsCore
+ */
+
+var Utils = function (_UtilsCore) {
+	_inherits(Utils, _UtilsCore);
+
+	function Utils() {
+		_classCallCheck(this, Utils);
+
+		return _possibleConstructorReturn(this, (Utils.__proto__ || Object.getPrototypeOf(Utils)).apply(this, arguments));
+	}
+
+	_createClass(Utils, null, [{
+		key: 'systemEndianness',
+
+
+		//-----------------------------------------------------------------------------
+		//
+		//  System values support (currently only endianness)
+		//
+		//-----------------------------------------------------------------------------
+
+		/**
+   * @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;
+		}
+
+		//-----------------------------------------------------------------------------
+		//
+		//  Function and function string validations
+		//
+		//-----------------------------------------------------------------------------
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'isFunction',
+		value: function isFunction(funcObj) {
+			return typeof funcObj === 'function';
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'isFunctionString',
+		value: function isFunctionString(funcStr) {
+			if (funcStr !== null) {
+				return funcStr.toString().slice(0, 'function'.length).toLowerCase() === 'function';
+			}
+			return false;
+		}
+
+		/**
+   * @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)
+   *
+   */
+
+	}, {
+		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('}'));
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		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
+   *
+   */
+
+	}, {
+		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;
+				}
+			}
+
+			return temp;
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		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);
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		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);
+			};
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'isArray',
+		value: function isArray(array) {
+			if (isNaN(array.length)) {
+				return false;
+			}
+
+			return true;
+		}
+
+		/**
+   * @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/Float/Texture/Unknown
+   *
+   */
+
+	}, {
+		key: 'getArgumentType',
+		value: function getArgumentType(arg) {
+			if (Utils.isArray(arg)) {
+				if (arg[0].nodeName === 'IMG') {
+					return 'HTMLImageArray';
+				}
+				return 'Array';
+			} else if (typeof arg === 'number') {
+				if (Number.isInteger(arg)) {
+					return 'Integer';
+				}
+				return 'Float';
+			} else if (arg instanceof Texture) {
+				return arg.type;
+			} else if (arg instanceof Input) {
+				return 'Input';
+			} else if (arg.nodeName === 'IMG') {
+				return 'HTMLImage';
+			} else {
+				return 'Unknown';
+			}
+		}
+		/**
+   * @typedef {Object} gpuJSObject
+   */
+
+		/**
+   * @memberOf Utils
+   * @name isFloatReadPixelsSupported
+   * @function
+   * @static
+   *
+   * Checks if the browser supports readPixels with float type
+   *
+   * @returns {Boolean} true if browser supports
+   *
+   */
+
+	}, {
+		key: 'isFloatReadPixelsSupported',
+		value: function isFloatReadPixelsSupported() {
+			if (_isFloatReadPixelsSupported !== null) {
+				return _isFloatReadPixelsSupported;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl-validator'
+			});
+			var x = gpu.createKernel(function () {
+				return 1;
+			}, {
+				output: [2],
+				floatTextures: true,
+				floatOutput: true,
+				floatOutputForce: true
+			})();
+
+			_isFloatReadPixelsSupported = x[0] === 1;
+			gpu.destroy();
+			return _isFloatReadPixelsSupported;
+		}
+
+		/**
+   * @memberOf Utils
+   * @name isFloatReadPixelsSupportedWebGL2
+   * @function
+   * @static
+   *
+   * Checks if the browser supports readPixels with float type
+   *
+   * @returns {Boolean} true if browser supports
+   *
+   */
+
+	}, {
+		key: 'isFloatReadPixelsSupportedWebGL2',
+		value: function isFloatReadPixelsSupportedWebGL2() {
+			if (_isFloatReadPixelsSupportedWebGL2 !== null) {
+				return _isFloatReadPixelsSupportedWebGL2;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl2-validator'
+			});
+			var x = gpu.createKernel(function () {
+				return 1;
+			}, {
+				output: [2],
+				floatTextures: true,
+				floatOutput: true,
+				floatOutputForce: true
+			})();
+
+			_isFloatReadPixelsSupportedWebGL2 = x[0] === 1;
+			gpu.destroy();
+			return _isFloatReadPixelsSupportedWebGL2;
+		}
+
+		/**
+   * @memberOf Utils
+   * @name hasIntegerDivisionAccuracyBug
+   * @function
+   * @static
+   *
+   * Checks if the system has inaccuracies when dividing integers
+   *
+   * @returns {Boolean} true if bug is exhibited on this system
+   *
+   */
+
+	}, {
+		key: 'hasIntegerDivisionAccuracyBug',
+		value: function hasIntegerDivisionAccuracyBug() {
+			if (_hasIntegerDivisionAccuracyBug !== null) {
+				return _hasIntegerDivisionAccuracyBug;
+			}
+
+			var GPU = require('../index');
+			var gpu = new GPU({
+				mode: 'webgl-validator'
+			});
+			var x = gpu.createKernel(function (v1, v2) {
+				return v1[this.thread.x] / v2[this.thread.x];
+			}, {
+				output: [1]
+			})([6, 6030401], [3, 3991]);
+
+			// have we not got whole numbers for 6/3 or 6030401/3991
+			// add more here if others see this problem
+			_hasIntegerDivisionAccuracyBug = x[0] !== 2 || x[1] !== 1511;
+			gpu.destroy();
+			return _hasIntegerDivisionAccuracyBug;
+		}
+	}, {
+		key: 'isMixedIdentifiersSupported',
+		value: function isMixedIdentifiersSupported() {
+			return _isMixedIdentifiersSupported;
+		}
+	}, {
+		key: 'dimToTexSize',
+		value: function dimToTexSize(opt, dimensions, output) {
+			var numTexels = dimensions[0];
+			var w = dimensions[0];
+			var h = dimensions[1];
+			for (var i = 1; i < dimensions.length; i++) {
+				numTexels *= dimensions[i];
+			}
+
+			if (opt.floatTextures && (!output || opt.floatOutput)) {
+				w = numTexels = Math.ceil(numTexels / 4);
+			}
+			// if given dimensions == a 2d image
+			if (h > 1 && w * h === numTexels) {
+				return [w, h];
+			}
+			// find as close to square width, height sizes as possible
+			var sqrt = Math.sqrt(numTexels);
+			var high = Math.ceil(sqrt);
+			var low = Math.floor(sqrt);
+			while (high * low > numTexels) {
+				high--;
+				low = Math.ceil(numTexels / high);
+			}
+			w = low;
+			h = Math.ceil(numTexels / w);
+			return [w, h];
+		}
+
+		/**
+   * @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]
+   *
+   *
+   *
+   */
+
+	}, {
+		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;
+			return new Int32Array(ret);
+		}
+
+		/**
+   * @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.
+   *
+   */
+
+	}, {
+		key: 'pad',
+		value: function pad(arr, padding) {
+			function zeros(n) {
+				return Array.apply(null, new Array(n)).map(Number.prototype.valueOf, 0);
+			}
+
+			var len = arr.length + padding * 2;
+
+			var ret = arr.map(function (x) {
+				return [].concat(zeros(padding), x, zeros(padding));
+			});
+
+			for (var i = 0; i < padding; i++) {
+				ret = [].concat([zeros(len)], ret, [zeros(len)]);
+			}
+
+			return ret;
+		}
+
+		/**
+   * @memberOf Utils
+   * @name flatten2dArrayTo
+   * @function
+   * @static
+   *
+   * 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;
+			}
+		}
+
+		/**
+   * @memberOf Utils
+   * @name flatten3dArrayTo
+   * @function
+   * @static
+   *
+   * 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;
+				}
+			}
+		}
+
+		/**
+   * @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
+   */
+
+	}, {
+		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);
+			}
+		}
+
+		/**
+   * @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
+   *
+   */
+
+	}, {
+		key: 'splitArray',
+		value: function splitArray(array, part) {
+			var result = [];
+			for (var i = 0; i < array.length; i += part) {
+				result.push(new array.constructor(array.buffer, i * 4 + array.byteOffset, 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 = [];
+
+			do {
+				props.push.apply(props, Object.getOwnPropertyNames(obj));
+			} while (obj = Object.getPrototypeOf(obj));
+
+			return props;
+		}
+	}]);
+
+	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;
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 8f24f15e..2ebcec5d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8161,44 +8161,36 @@
         "vinyl": "^2.1.0"
       },
       "dependencies": {
-        "isarray": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-          "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+        "clone": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz",
+          "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=",
           "dev": true
         },
-        "readable-stream": {
-          "version": "2.3.6",
-          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
-          "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
-          "dev": true,
-          "requires": {
-            "core-util-is": "~1.0.0",
-            "inherits": "~2.0.3",
-            "isarray": "~1.0.0",
-            "process-nextick-args": "~2.0.0",
-            "safe-buffer": "~5.1.1",
-            "string_decoder": "~1.1.1",
-            "util-deprecate": "~1.0.1"
-          }
+        "clone-stats": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz",
+          "integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=",
+          "dev": true
         },
-        "string_decoder": {
-          "version": "1.1.1",
-          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-          "dev": true,
-          "requires": {
-            "safe-buffer": "~5.1.0"
-          }
+        "replace-ext": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
+          "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
+          "dev": true
         },
-        "through2": {
-          "version": "2.0.5",
-          "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz",
-          "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
+        "vinyl": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.0.tgz",
+          "integrity": "sha512-MBH+yP0kC/GQ5GwBqrTPTzEfiiLjta7hTtvQtbxBgTeSXsmKQRQecjibMbxIXzVT3Y9KJK+drOz1/k+vsu8Nkg==",
           "dev": true,
           "requires": {
-            "readable-stream": "~2.3.6",
-            "xtend": "~4.0.1"
+            "clone": "^2.1.1",
+            "clone-buffer": "^1.0.0",
+            "clone-stats": "^1.0.0",
+            "cloneable-readable": "^1.0.0",
+            "remove-trailing-separator": "^1.0.1",
+            "replace-ext": "^1.0.0"
           }
         }
       }
diff --git a/src/backend/kernel-base.js b/src/backend/kernel-base.js
new file mode 100644
index 00000000..df9e6d3c
--- /dev/null
+++ b/src/backend/kernel-base.js
@@ -0,0 +1,452 @@
+'use strict';
+
+const utils = require('../core/utils');
+const Input = require('../core/input');
+
+module.exports = class KernelBase {
+
+	/**
+	 * @constructor KernelBase
+	 *
+	 * @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
+	 * @prop {Boolean} fixIntegerDivisionAccuracy - fix issues with some graphics cards not returning whole numbers when dividing by factors of 3
+	 *
+	 */
+	constructor(fnString, settings) {
+		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.outputImmutable = 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.subKernels = null;
+		this.subKernelProperties = null;
+		this.subKernelNames = null;
+		this.subKernelOutputVariableNames = null;
+		this.functionBuilder = null;
+		this.paramTypes = null;
+		this.paramSizes = null;
+		this.constantTypes = null;
+		this.fixIntegerDivisionAccuracy = null;
+		this.constrainStart = null;
+		this.constrainEnd = null;
+
+		for (let 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('webGl')) {
+			this._webGl = settings.webGl;
+		}
+		if (settings.hasOwnProperty('output')) {
+			this.setOutput(settings.output); // Flatten output object
+		}
+
+		if (!this._canvas) this._canvas = utils.initCanvas();
+	}
+
+	build() {
+		throw new Error('"build" not defined on Base');
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setupParams
+	 *
+	 * @desc Setup the parameter types for the parameters
+	 * supplied to the Kernel function
+	 *
+	 * @param {IArguments} args - The actual parameters sent to the Kernel
+	 *
+	 */
+	setupParams(args) {
+		this.paramTypes = [];
+		this.paramSizes = [];
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+
+			this.paramTypes.push(utils.getArgumentType(arg));
+			this.paramSizes.push(arg.constructor === Input ? arg.size : null);
+		}
+	}
+
+	setupConstants() {
+		this.constantTypes = {};
+		if (this.constants) {
+			for (let p in this.constants) {
+				this.constantTypes[p] = utils.getArgumentType(this.constants[p])
+			}
+		}
+	}
+
+	setFunctions(functions) {
+		this.functions = functions;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setOutput
+	 *
+	 * @desc Set dimensions of the kernel function
+	 *
+	 * @param {Array|Object} output - The output array to set the kernel output size to
+	 *
+	 */
+	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;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setDebug
+	 *
+	 * @desc Toggle debug mode
+	 *
+	 * @param {Boolean} flag - true to enable debug
+	 *
+	 */
+	setDebug(flag) {
+		this.debug = flag;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setGraphical
+	 *
+	 * @desc Toggle graphical output mode
+	 *
+	 * @param {Boolean} flag - true to enable graphical output
+	 *
+	 */
+	setGraphical(flag) {
+		this.graphical = flag;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name constrain
+	 *
+	 * @desc constrain kernel to operate on subset quad of matrix
+	 *
+	 * @param {Array} start - [x, y, z]
+	 * @param {Array} end - [x, y, z]
+	 *
+	 */
+	constrain(start, end) {
+		this.constrainStart = start || null;
+		this.constrainEnd = end || null;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name deconstrain
+	 *
+	 * @desc remove constraint on kernelin order to operate on entire matrix
+	 */
+	deconstrain() {
+		this.constrainStart = null;
+		this.constrainEnd = null;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setLoopMaxIterations
+	 *
+	 * @desc Set the maximum number of loop iterations
+	 *
+	 * @param {number} max - iterations count
+	 *
+	 */
+	setLoopMaxIterations(max) {
+		this.loopMaxIterations = max;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setFixIntegerDivisionAccuracy
+	 *
+	 * @desc Fix division by factor of 3 FP accuracy bug
+	 *
+	 * @param {Boolean} fix - should fix
+	 *
+	 */
+	setFixIntegerDivisionAccuracy(fix) {
+		this.fixIntegerDivisionAccuracy = fix;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setConstants
+	 * @desc Set Constants
+	 */
+	setConstants(constants) {
+		this.constants = constants;
+		return this;
+	}
+
+	setWraparound(flag) {
+		console.warn('Wraparound mode is not supported and undocumented.');
+		this.wraparound = flag;
+		return this;
+	}
+
+	setHardcodeConstants(flag) {
+		this.hardcodeConstants = flag;
+		return this;
+	}
+
+	setOutputToTexture(flag) {
+		this.outputToTexture = flag;
+		return this;
+	}
+
+	setOutputImmutable(flag) {
+		this.outputImmutable = flag;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setFloatTextures
+	 *
+	 * @desc Toggle texture output mode
+	 *
+	 * @param {Boolean} flag - true to enable floatTextures
+	 *
+	 */
+	setFloatTextures(flag) {
+		this.floatTextures = flag;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setFloatOutput
+	 *
+	 * @desc Toggle output mode
+	 *
+	 * @param {Boolean} flag - true to enable float
+	 *
+	 */
+	setFloatOutput(flag) {
+		this.floatOutput = flag;
+		return this;
+	}
+
+	setFloatOutputForce(flag) {
+		this.floatOutputForce = flag;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setCanvas
+	 *
+	 * @desc Bind the canvas to kernel
+	 *
+	 * @param {Canvas} canvas - Canvas to bind
+	 *
+	 */
+	setCanvas(canvas) {
+		this._canvas = canvas;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name setCanvas
+	 *
+	 * @desc Bind the webGL instance to kernel
+	 *
+	 * @param {Canvas} webGL - webGL instance to bind
+	 *
+	 */
+	setWebGl(webGl) {
+		this._webGl = webGl;
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name getCanvas()
+	 *
+	 * @desc Returns the current canvas instance bound to the kernel
+	 *
+	 */
+	getCanvas() {
+		return this._canvas;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @function
+	 * @name getWebGl()
+	 *
+	 * @desc Returns the current webGl instance bound to the kernel
+	 *
+	 */
+	getWebGl() {
+		return this._webGl;
+	}
+
+	validateOptions() {
+		throw new Error('validateOptions not defined');
+	}
+
+	exec() {
+		return this.execute.apply(this, arguments);
+	}
+
+	execute() {
+		//
+		// Prepare the required objects
+		//
+		const 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((accept, reject) => {
+			try {
+				accept(this.run.apply(this, args));
+			} catch (e) {
+				//
+				// Error : throw rejection
+				//
+				reject(e);
+			}
+		});
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @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
+	 *
+	 */
+	addSubKernel(fnString) {
+		if (this.subKernels === null) {
+			this.subKernels = [];
+			this.subKernelNames = [];
+		}
+		this.subKernels.push(fnString);
+		this.subKernelNames.push(utils.getFunctionNameFromString(fnString));
+		return this;
+	}
+
+	/**
+	 * @memberOf KernelBase#
+	 * @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
+	 *
+	 */
+	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;
+	}
+
+	addNativeFunction(name, source) {
+		this.functionBuilder.addNativeFunction(name, source);
+	}
+
+	/**
+	 *
+	 * Destroys all memory associated with this kernel
+	 *
+	 * @name destroy
+	 * @function
+	 * @memberOf KernelBase#
+	 *
+	 * * @param {Boolean} removeCanvasReferences remve any associated canvas references?
+	 *
+	 */
+	destroy() {
+
+	}
+};
\ No newline at end of file
diff --git a/src/backend/web-gl/kernel.js b/src/backend/web-gl/kernel.js
index 47443384..bf542ec3 100644
--- a/src/backend/web-gl/kernel.js
+++ b/src/backend/web-gl/kernel.js
@@ -442,6 +442,61 @@ class WebGLKernel extends GLKernel {
 			}
 		}
 
+		if (this.constrainStart || this.constrainEnd) {
+
+			gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+			if (this.constrainStart) {
+
+			} else {
+
+			}
+			if (this.constrainEnd) {
+
+			} else {
+
+			}
+			var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0,
+				0.5, -0.5, 0.0,
+				0.5, 0.5, 0.0
+			];
+
+			var indices = [3, 2, 1, 3, 1, 0];
+
+			// Create an empty buffer object to store vertex buffer
+			var vertex_buffer = gl.createBuffer();
+
+			// Bind appropriate array buffer to it
+			gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+			// Pass the vertex data to the buffer
+			gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+			// Unbind the buffer
+			gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+			// Create an empty buffer object to store Index buffer
+			var Index_Buffer = gl.createBuffer();
+
+			// Bind appropriate array buffer to it
+			gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+			// Pass the vertex data to the buffer
+			gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+			// Unbind the buffer
+			gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+			// original
+
+			gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+			gl.drawArrays(gl.TRIANGLES, 0, 6);
+			this._setupOutputTexture();
+			return this.renderOutput(this.outputTexture);
+		}
+
 		if (this.graphical) {
 			if (this.pipeline) {
 				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
diff --git a/src/backend/web-gl2/kernel.js b/src/backend/web-gl2/kernel.js
index 1f4f01ca..0eb5e40d 100644
--- a/src/backend/web-gl2/kernel.js
+++ b/src/backend/web-gl2/kernel.js
@@ -208,6 +208,60 @@ class WebGL2Kernel extends WebGLKernel {
 			}
 		}
 
+		if (this.constrainStart || this.constrainEnd) {
+
+			gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+
+			if (this.constrainStart) {
+
+			} else {
+
+			}
+			if (this.constrainEnd) {
+
+			} else {
+
+			}
+			var vertices = [-0.5, 0.5, 0.0, -0.5, -0.5, 0.0,
+				0.5, -0.5, 0.0,
+				0.5, 0.5, 0.0
+			];
+
+			var indices = [3, 2, 1, 3, 1, 0];
+
+			// Create an empty buffer object to store vertex buffer
+			var vertex_buffer = gl.createBuffer();
+
+			// Bind appropriate array buffer to it
+			gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
+
+			// Pass the vertex data to the buffer
+			gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+
+			// Unbind the buffer
+			gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+			// Create an empty buffer object to store Index buffer
+			var Index_Buffer = gl.createBuffer();
+
+			// Bind appropriate array buffer to it
+			gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, Index_Buffer);
+
+			// Pass the vertex data to the buffer
+			gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+
+			// Unbind the buffer
+			gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+			// original
+
+			gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+			gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+			gl.drawArrays(gl.TRIANGLES, 0, 6);
+			return;
+		}
+
 		if (this.graphical) {
 			if (this.pipeline) {
 				gl.bindRenderbuffer(gl.RENDERBUFFER, null);
diff --git a/test/all.html b/test/all.html
index 0aa636c1..967bd3cd 100644
--- a/test/all.html
+++ b/test/all.html
@@ -34,39 +34,38 @@
   <script src="../node_modules/qunit/qunit/qunit.js"></script>
 
   <!-- features -->
-  <script type="module" src="features/add-custom-function.js"></script>
-  <script type="module" src="features/add-custom-native-function.js"></script>
-  <script type="module" src="features/add-typed-functions.js"></script>
-  <script type="module" src="features/basic-math.js"></script>
-  <script type="module" src="features/combine-kernels.js"></script>
-  <script type="module" src="features/constants-array.js"></script>
-  <script type="module" src="features/constants-float.js"></script>
-  <script type="module" src="features/constants-image.js"></script>
-  <script type="module" src="features/constants-image-array.js"></script>
-  <script type="module" src="features/constants-integer.js"></script>
-  <script type="module" src="features/constants-texture.js"></script>
-  <script type="module" src="features/create-kernel-map.js"></script>
-  <script type="module" src="features/demo.js"></script>
-  <script type="module" src="features/float-output.js"></script>
-  <script type="module" src="features/function-return.js"></script>
-  <script type="module" src="features/get-canvas.js"></script>
-  <script type="module" src="features/if-else.js"></script>
-  <script type="module" src="features/image.js"></script>
-  <script type="module" src="features/image-array.js"></script>
-  <script type="module" src="features/infinity.js"></script>
-  <script type="module" src="features/input.js"></script>
-  <script type="module" src="features/json.js"></script>
-  <script type="module" src="features/loops.js"></script>
-  <script type="module" src="features/math-object.js"></script>
-  <script type="module" src="features/nested-function.js"></script>
-  <script type="module" src="features/promise-api.js"></script>
-  <script type="module" src="features/read-color-texture.js"></script>
-  <script type="module" src="features/read-from-texture.js"></script>
-  <script type="module" src="features/float-output.js"></script>
-  <script type="module" src="features/offscreen-canvas.js"></script>
-  <script type="module" src="features/to-string.js"></script>
-  <script type="module" src="features/ternary.js"></script>
-  <script type="module" src="features/type-management.js"></script>
+  <script src="features/add-custom-function.js"></script>
+  <script src="features/add-custom-native-function.js"></script>
+  <script src="features/add-typed-functions.js"></script>
+  <script src="features/combine-kernels.js"></script>
+  <script src="features/constants-array.js"></script>
+  <script src="features/constants-float.js"></script>
+  <script src="features/constants-image.js"></script>
+  <script src="features/constants-image-array.js"></script>
+  <script src="features/constants-integer.js"></script>
+  <script src="features/constants-texture.js"></script>
+  <script src="features/constrain.js"></script>
+  <script src="features/create-kernel-map.js"></script>
+  <script src="features/demo.js"></script>
+  <script src="features/float-output.js"></script>
+  <script src="features/for-loop.js"></script>
+  <script src="features/function-return.js"></script>
+  <script src="features/get-canvas.js"></script>
+  <script src="features/if-else.js"></script>
+  <script src="features/image.js"></script>
+  <script src="features/image-array.js"></script>
+  <script src="features/infinity.js"></script>
+  <script src="features/input.js"></script>
+  <script src="features/mult-ab.js"></script>
+  <script src="features/nested-function.js"></script>
+  <script src="features/promise-api.js"></script>
+  <script src="features/read-color-texture.js"></script>
+  <script src="features/read-from-texture.js"></script>
+  <script src="features/sum-ab.js"></script>
+  <script src="features/float-output.js"></script>
+  <script src="features/offscreen-canvas.js"></script>
+  <script src="features/to-string.js"></script>
+  <script src="features/type-management.js"></script>
 
   <!-- internal -->
   <script type="module" src="internal/context-inheritance.js"></script>
diff --git a/test/features/constrain.js b/test/features/constrain.js
new file mode 100644
index 00000000..f9612332
--- /dev/null
+++ b/test/features/constrain.js
@@ -0,0 +1,55 @@
+(function() {
+  function constrainTest(mode) {
+    var gpu = new GPU({ mode: mode });
+    var f = gpu.createKernel(function() {
+      return 255;
+    }, {
+      output : [3, 4, 4]
+    });
+    let x = 2;
+    let y = 2;
+    let z = 2;
+    let width = 2;
+    let height = 2;
+    let depth = 3;
+    let result = f();
+    QUnit.assert.deepValueEqual(QUnit.extend([], result), [
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]]]);
+    f.constrain({x, y, z}, [width, height, depth]);
+    let resultConstrained = f();
+    QUnit.assert.deepValueEqual(QUnit.extend([], resultConstrained), [
+      [[255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255]]]);
+    f.deconstrain();
+    let resultDeconstrained = f();
+    QUnit.assert.deepValueEqual(QUnit.extend([], resultDeconstrained), [
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]],
+      [[255, 255, 255], [255, 255, 255], [255, 255, 255], [255, 255, 255]]]);
+    gpu.destroy();
+  }
+
+  QUnit.test('constrain (auto)', function() {
+  	constrainTest(null);
+  });
+
+  QUnit.test('constrain (gpu)', function() {
+  	constrainTest('gpu');
+  });
+
+  QUnit.test('constrain (webgl)', function() {
+    constrainTest('webgl');
+  });
+
+  QUnit.test('constrain (webgl2)', function() {
+    constrainTest('webgl2');
+  });
+
+  QUnit.test('constrain (CPU)', function() {
+    constrainTest('cpu');
+  });
+})();