initial commit

node_modules/mumath/.eslintrc.json

@@ -0,0 +1,43 @@
+{
+    "env": {
+        "browser": true,
+        "node": true,
+        "commonjs": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "strict": 2,
+        "indent": 0,
+        "linebreak-style": 0,
+        "quotes": 0,
+        "semi": 0,
+        "no-cond-assign": 1,
+        "no-constant-condition": 1,
+        "no-duplicate-case": 1,
+        "no-empty": 1,
+        "no-ex-assign": 1,
+        "no-extra-boolean-cast": 1,
+        "no-extra-semi": 1,
+        "no-fallthrough": 1,
+        "no-func-assign": 1,
+        "no-global-assign": 1,
+        "no-implicit-globals": 2,
+        "no-inner-declarations": ["error", "functions"],
+        "no-irregular-whitespace": 2,
+        "no-loop-func": 1,
+        "no-multi-str": 1,
+        "no-mixed-spaces-and-tabs": 1,
+        "no-proto": 1,
+        "no-sequences": 1,
+        "no-throw-literal": 1,
+        "no-unmodified-loop-condition": 1,
+        "no-useless-call": 1,
+        "no-void": 1,
+        "no-with": 2,
+        "wrap-iife": 1,
+        "no-redeclare": 1,
+        "no-unused-vars": ["error", { "vars": "all", "args": "none" }],
+        "no-sparse-arrays": 1
+    }
+}

node_modules/mumath/.npmignore

@@ -0,0 +1,38 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+node_modules
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+bundle.js
+demo
+
+images

node_modules/mumath/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "4"
+  - "6"
+  - "node"

node_modules/mumath/README.md

@@ -0,0 +1,85 @@
+# μMath [![Build Status](https://travis-ci.org/dfcreative/mumath.svg?branch=master)](https://travis-ci.org/dfcreative/mumath) [![Code Climate](https://codeclimate.com/github/dfcreative/mumath/badges/gpa.svg)](https://codeclimate.com/github/dfcreative/mumath) <a href="UNLICENSE"><img src="http://upload.wikimedia.org/wikipedia/commons/6/62/PD-icon.svg" width="20"/></a>
+
+Set of practical math utils to shorten code.
+
+[`$ npm install mumath`](https://npmjs.org/package/mumath)
+
+```js
+var round = require('mumath/round');
+round(123.32, .5); //123.5
+
+//require any function as
+//var <fn> = require('mumath/<fn>');
+```
+
+## API
+
+### `round(value, step?)`
+
+Rounds value to optional `step`.
+
+`round(0.3, .5)` → `.5`
+
+
+### `len(a, b)`
+
+Return length of a vector.
+
+
+### `precision(value)`
+
+Get precision from float:
+
+`1.1 → 1, 1234 → 0, .1234 → 4`
+
+
+### `clamp(value, left, right)`
+
+Return value clamped by left/right limits (or vice-versa).
+
+
+### `lerp(x, y, ratio)`
+
+Return value interpolated between x and y.
+
+
+### `within(value, left, right)`
+
+Whether element is between left & right, including.
+
+
+### `mod(value, min?, max)`
+
+An enhanced [mod-loop](http://npmjs.org/package/mod-loop) — loops value within a frame.
+
+
+### `closest(value, list)`
+
+Get closest value out of a set.
+
+
+### `scale(value, list)`
+
+Get first scale out of a list of basic scales, aligned to the power. E. g.
+
+`step(.37, [1, 2, 5])` → `.5`
+`step(456, [1, 2])` → `1000`
+
+Similar to closest, but takes all possible powers of scales.
+
+### `order(value)`
+
+Get order of magnitude for a number.
+
+`order(123) → 100; order(-0.0003) → 0.0001;`
+
+
+### `isMultiple(a, b, eps?)`
+
+Same as `a % b === 0`, but with precision check.
+
+
+## Related
+
+* [bit-twiddle](https://www.npmjs.com/package/bit-twiddle) — utils for power-of-two numbers.
+* [pretty-number](https://www.npmjs.com/package/pretty-number) — format number to pretty view.

node_modules/mumath/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

node_modules/mumath/clamp.js

@@ -0,0 +1,14 @@
+/**
+ * Clamp value.
+ * Detects proper clamp min/max.
+ *
+ * @param {number} a Current value to cut off
+ * @param {number} min One side limit
+ * @param {number} max Other side limit
+ *
+ * @return {number} Clamped value
+ */
+'use strict';
+module.exports = function(a, min, max){
+	return max > min ? Math.max(Math.min(a,max),min) : Math.max(Math.min(a,min),max);
+};

node_modules/mumath/closest.js

@@ -0,0 +1,17 @@
+/**
+ * @module  mumath/closest
+ */
+'use strict';
+
+module.exports = function closest (num, arr) {
+	var curr = arr[0];
+	var diff = Math.abs (num - curr);
+	for (var val = 0; val < arr.length; val++) {
+		var newdiff = Math.abs (num - arr[val]);
+		if (newdiff < diff) {
+			diff = newdiff;
+			curr = arr[val];
+		}
+	}
+	return curr;
+}

node_modules/mumath/index.js

@@ -0,0 +1,24 @@
+/**
+ * Composed set of all math utils, wrapped
+ *
+ * @module  mumath
+ */
+'use strict';
+const wrap = require('./wrap');
+
+module.exports = {
+	clamp: wrap(require('./clamp')),
+	within: wrap(require('./within')),
+	round: wrap(require('./round')),
+	precision: wrap(require('./precision')),
+	mod: wrap(require('./mod')),
+	log10: wrap(require('./log10')),
+	len: wrap(require('./len')),
+	closest: wrap(require('./closest')),
+	order: wrap(require('./order')),
+	lerp: wrap(require('./lerp')),
+	isMultiple: wrap(require('./is-multiple')),
+	normalize: wrap(require('./normalize')),
+	scale: wrap(require('./scale')),
+	// pretty: wrap(require('./pretty')),
+};

node_modules/mumath/is-multiple.js

@@ -0,0 +1,20 @@
+/**
+ * Check if one number is multiple of other
+ *
+ * @module  mumath/is-multiple
+ */
+'use strict';
+var almost = require('almost-equal');
+
+module.exports = isMultiple;
+
+function isMultiple (a, b, eps) {
+	var remainder = a % b;
+
+	if (!eps) eps = almost.FLT_EPSILON;
+
+	if (!remainder) return true;
+	if (almost(0, remainder, eps, 0) || almost(Math.abs(b), Math.abs(remainder), eps, 0)) return true;
+
+	return false;
+}

node_modules/mumath/len.js

@@ -0,0 +1,11 @@
+/**
+ * Return quadratic length
+ *
+ * @module  mumath/loop
+ *
+ */
+'use strict';
+
+module.exports = function (a, b) {
+	return Math.sqrt(a*a + b*b);
+};

node_modules/mumath/lerp.js

@@ -0,0 +1,7 @@
+/**
+ * @module mumath/lerp
+ */
+'use strict';
+module.exports = function (x, y, a) {
+	return x * (1.0 - a) + y * a;
+};

node_modules/mumath/log10.js

@@ -0,0 +1,9 @@
+/**
+ * Base 10 logarithm
+ *
+ * @module mumath/log10
+ */
+'use strict';
+module.exports = Math.log10 || function (a) {
+	return Math.log(a) / Math.log(10);
+};

node_modules/mumath/mod.js

@@ -0,0 +1,31 @@
+/**
+ * Looping function for any framesize.
+ * Like fmod.
+ *
+ * @module  mumath/loop
+ *
+ */
+
+'use strict';
+module.exports = function (value, left, right) {
+	//detect single-arg case, like mod-loop or fmod
+	if (right === undefined) {
+		right = left;
+		left = 0;
+	}
+
+	//swap frame order
+	if (left > right) {
+		var tmp = right;
+		right = left;
+		left = tmp;
+	}
+
+	var frame = right - left;
+
+	value = ((value + left) % frame) - left;
+	if (value < left) value += frame;
+	if (value > right) value -= frame;
+
+	return value;
+};

node_modules/mumath/normalize.js

@@ -0,0 +1,35 @@
+/**
+ * Get rid of float remainder
+ *
+ * @module mumath/normalize
+ */
+'use strict';
+
+var almost = require('almost-equal');
+
+module.exports = function(value, eps) {
+	//ignore ints
+	var rem = value%1;
+	if (!rem) return value;
+
+	if (eps == null) eps = Number.EPSILON || almost.FLT_EPSILON;
+
+	//pick number’s neighbour, which is way shorter, like 0.4999999999999998 → 0.5
+	//O(20)
+	var range = 5;
+	var len = (rem+'').length;
+
+	for (var i = 1; i < range; i+=.5) {
+		var left = rem - eps*i,
+			right = rem + eps*i;
+
+		var leftStr = left+'', rightStr = right + '';
+
+		if (len - leftStr.length > 2) return value - eps*i;
+		if (len - rightStr.length > 2) return value + eps*i;
+
+		// if (leftStr[2] != rightStr[2])
+	}
+
+	return value;
+};

node_modules/mumath/order.js

@@ -0,0 +1,9 @@
+/**
+ * @module mumath/order
+ */
+'use strict';
+module.exports = function (n) {
+	n = Math.abs(n);
+	var order = Math.floor(Math.log(n) / Math.LN10 + 0.000000001);
+	return Math.pow(10,order);
+};

node_modules/mumath/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "mumath",
+  "version": "3.3.4",
+  "description": "Practical math utils for components",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dfcreative/mumath.git"
+  },
+  "keywords": [
+    "math",
+    "geometry"
+  ],
+  "author": "dfcreative",
+  "license": "Unlicense",
+  "bugs": {
+    "url": "https://github.com/dfcreative/mumath/issues"
+  },
+  "homepage": "https://github.com/dfcreative/mumath",
+  "dependencies": {
+    "almost-equal": "^1.1.0"
+  }
+}

node_modules/mumath/precision.js

@@ -0,0 +1,40 @@
+/**
+ * @module  mumath/precision
+ *
+ * Get precision from float:
+ *
+ * @example
+ * 1.1 → 1, 1234 → 0, .1234 → 4
+ *
+ * @param {number} n
+ *
+ * @return {number} decimap places
+ */
+'use strict';
+
+var almost = require('almost-equal');
+var norm = require('./normalize');
+
+module.exports = function (n, eps) {
+	n = norm(n);
+
+	var str = n + '';
+
+	//1e-10 etc
+	var e = str.indexOf('e-');
+	if (e >= 0) return parseInt(str.substring(e+2));
+
+	//imperfect ints, like 3.0000000000000004 or 1.9999999999999998
+	var remainder = Math.abs(n % 1);
+	var remStr = remainder + '';
+
+	if (almost(remainder, 1, eps) || almost(remainder, 0, eps)) return 0;
+
+	//usual floats like .0123
+	var d = remStr.indexOf('.') + 1;
+
+	if (d) return remStr.length - d;
+
+	//regular inte
+	return 0;
+};

node_modules/mumath/pretty.js

@@ -0,0 +1,23 @@
+/**
+ * Format number nicely
+ *
+ * @module  mumath/loop
+ *
+ */
+'use strict';
+
+var precision = require('./precision');
+var almost = require('almost-equal');
+var normalize = require('./normalize');
+
+module.exports = function (v, prec) {
+	if (almost(v, 0)) return '0';
+
+	if (prec == null) {
+		prec = precision(v);
+		prec = Math.min(prec, 20);
+	}
+
+	// return v.toFixed(prec);
+	return v.toFixed(prec);
+};

node_modules/mumath/round.js

@@ -0,0 +1,22 @@
+/**
+ * Precision round
+ *
+ * @param {number} value
+ * @param {number} step Minimal discrete to round
+ *
+ * @return {number}
+ *
+ * @example
+ * toPrecision(213.34, 1) == 213
+ * toPrecision(213.34, .1) == 213.3
+ * toPrecision(213.34, 10) == 210
+ */
+'use strict';
+var precision = require('./precision');
+
+module.exports = function(value, step) {
+	if (step === 0) return value;
+	if (!step) return Math.round(value);
+	value = Math.round(value / step) * step;
+	return parseFloat(value.toFixed(precision(step)));
+};

node_modules/mumath/scale.js

@@ -0,0 +1,26 @@
+/**
+ * Get step out of the set
+ *
+ * @module mumath/step
+ */
+'use strict';
+
+var lg = require('./log10');
+
+module.exports = function (minStep, srcSteps) {
+	var power = Math.floor(lg(minStep));
+
+	var order = Math.pow(10, power);
+	var steps = srcSteps.map(v => v*order);
+	order = Math.pow(10, power+1);
+	steps = steps.concat(srcSteps.map(v => v*order));
+
+	//find closest scale
+	var step = 0;
+	for (var i = 0; i < steps.length; i++) {
+		step = steps[i];
+		if (step >= minStep) break;
+	}
+
+	return step;
+};

node_modules/mumath/test/index.js

@@ -0,0 +1,108 @@
+var m = require('../index');
+var assert = require('assert');
+
+// assert.equal(m.min(0,2),0);
+// assert.equal(m.max(0,2),2);
+// assert.deepEqual(m.min([0,0],[2,-2]),[0,-2]);
+
+assert.equal(m.clamp(-100, 0, 100), 0);
+assert.equal(m.clamp(-100, 100, 0), 0);
+assert.equal(m.clamp(-Infinity, -100, 0), -100);
+
+//limit arrays
+assert.deepEqual(m.clamp([-100, -200], -100, 100),  [-100, -100]);
+assert.deepEqual(m.clamp([-101, 101], [-50, -100], [100, 50]), [-50, 50]);
+
+//limit objects
+assert.deepEqual(m.clamp({top: 120, bottom: -10}, 0, 100), {top: 100, bottom: 0});
+assert.deepEqual(m.clamp({top: 120, bottom: -10}, {top: 0, bottom:0},  {top: 100, bottom: 100}), {top: 100, bottom: 0});
+
+//normalize
+assert.equal(m.normalize(-0.4999999999999998), -.5);
+assert.equal(m.normalize(1.5000000000000002), 1.5);
+assert.equal(m.normalize(10.5000000000000002), 10.5);
+assert.equal(m.normalize(-0.7999999999999996), -.8);
+
+
+//precisions
+assert.equal(m.precision(1.0000000000000005e+33), 0);
+assert.equal(m.precision(3.0000000000000004), 0);
+assert.equal(m.precision(1.9999999999999998), 0);
+assert.equal(m.precision(0.02), 2);
+assert.equal(m.precision(100), 0);
+assert.equal(m.precision(1e-1), 1);
+assert.equal(m.precision(1e-5), 5);
+assert.equal(m.precision(1e-19), 19);
+assert.equal(m.precision(1.0000000000000001e+33), 0);
+assert.equal(m.precision(-0.4999999999999998), 1);
+assert.equal(m.precision(1.5000000000000002), 1);
+assert.equal(m.precision(-0.7999999999999996), 1);
+
+
+assert.equal(m.round(0.3, .5), .5);
+
+//multiple
+assert.equal(m.isMultiple(100,10), true);
+assert.equal(m.isMultiple(100.1,10, .1), true);
+
+//loop
+assert.equal(m.mod(10, 100), 10);
+
+assert.equal(m.mod(110, 100), 10);
+assert.equal(m.mod(110, 90), 20);
+
+assert.equal(m.mod(-110, 100), 90);
+
+assert.equal(m.mod(110, 0, 100), 10);
+assert.equal(m.mod(110, -10, 100), 0);
+assert.equal(m.mod(110, -10, 90), 10);
+assert.equal(m.mod(-110, -100, 0), -10);
+assert.equal(m.mod(-110, -100, 10), 0);
+assert.equal(m.mod(-110, -90, 10), -10);
+
+//lg
+assert.equal(m.log10(100), 2);
+assert.equal(m.log10(10), 1);
+assert.equal(m.log10(1), 0);
+assert.equal(Math.round(m.log10(0.1)), -1);
+
+//len
+assert.equal(m.len(3,4), 5);
+
+//closest
+assert.equal(m.closest(0.2, [0.01, 0.1, 1, 10, 100]), 0.1);
+
+//order
+assert.equal(m.order(123), 100);
+assert.equal(m.order(0.000213), 0.0001);
+assert.equal(m.order(-123), 100);
+assert.equal(m.order(-0.0000123), 0.00001);
+
+assert(m.within(1, 0, 2));
+assert(m.within(1, 2, 0));
+assert(!m.within(0, 2, 1));
+
+
+assert.equal(m.lerp(1,0,.5), .5);
+
+
+//step
+assert.equal(m.scale(.1, [1, 2, 5]), .1);
+assert.equal(m.scale(.1, [1, 2, 5]), .1);
+
+
+
+//formatting
+// assert.equal(m.pretty(1.9999999999999998), '2');
+// assert.equal(m.pretty(1.0000000000000005e+33), '1e+33');
+// assert.equal(m.pretty(0.1), '0.1');
+// assert.equal(m.pretty(3.0000000000000004), '3');
+// assert.equal(m.pretty(7.0000000000000036, 2), '7');
+// assert.equal(m.pretty(3.885780586188048e-16), '0');
+// assert.equal(m.pretty(-1.9999999999999993), '-2');
+// assert.equal(m.pretty(-0.9999999999999996), '-1');
+// assert.equal(m.pretty(1.5000000000000002), '1.5');
+// assert.equal(m.pretty(-0.4999999999999998), '-0.5');
+// assert.equal(m.pretty(-0.7999999999999996), '-0.8');
+// assert.equal(m.pretty(500), '500');
+// assert.equal(m.pretty(0.4000000000000002), '0.4');

node_modules/mumath/within.js

@@ -0,0 +1,19 @@
+/**
+ * Whether element is between left & right including
+ *
+ * @param {number} a
+ * @param {number} left
+ * @param {number} right
+ *
+ * @return {Boolean}
+ */
+'use strict';
+module.exports = function(a, left, right){
+	if (left > right) {
+		var tmp = left;
+		left = right;
+		right = tmp;
+	}
+	if (a <= right && a >= left) return true;
+	return false;
+};

node_modules/mumath/wrap.js

@@ -0,0 +1,38 @@
+/**
+ * Get fn wrapped with array/object attrs recognition
+ *
+ * @return {Function} Target function
+ */
+'use strict';
+module.exports = function(fn){
+	return function (a) {
+		var args = arguments;
+		if (a instanceof Array) {
+			var result = new Array(a.length), slice;
+			for (var i = 0; i < a.length; i++){
+				slice = [];
+				for (var j = 0, l = args.length, val; j < l; j++){
+					val = args[j] instanceof Array ? args[j][i] : args[j];
+					slice.push(val);
+				}
+				result[i] = fn.apply(this, slice);
+			}
+			return result;
+		}
+		else if (typeof a === 'object') {
+			var result = {}, slice;
+			for (var i in a){
+				slice = [];
+				for (var j = 0, l = args.length, val; j < l; j++){
+					val = typeof args[j] === 'object' ? args[j][i] : args[j];
+					slice.push(val);
+				}
+				result[i] = fn.apply(this, slice);
+			}
+			return result;
+		}
+		else {
+			return fn.apply(this, args);
+		}
+	};
+};