Update to v13 and add queue and completely change code

node_modules/timers-ext/.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+
+[{*.json,*.yml}]
+indent_style = space
+indent_size = 2

node_modules/timers-ext/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="0.1.7"></a>
+## [0.1.7](https://github.com/medikoo/timers-ext/compare/v0.1.6...v0.1.7) (2018-10-04)
+
+
+### Bug Fixes
+
+* typo in error message ([36720cf](https://github.com/medikoo/timers-ext/commit/36720cf))
+
+
+
+<a name="0.1.6"></a>
+## [0.1.6](https://github.com/medikoo/timers-ext/compare/v0.1.5...v0.1.6) (2018-10-04)
+
+
+### Features
+
+* report timeout value on error ([abb4afa](https://github.com/medikoo/timers-ext/commit/abb4afa))
+
+
+
+<a name="0.1.5"></a>
+## [0.1.5](https://github.com/medikoo/timers-ext/compare/v0.1.4...v0.1.5) (2018-03-13)
+
+
+### Features
+
+* **promise:** sleep util ([c50d575](https://github.com/medikoo/timers-ext/commit/c50d575))
+
+
+
+<a name="0.1.4"></a>
+## [0.1.4](https://github.com/medikoo/timers-ext/compare/v0.1.3...v0.1.4) (2018-03-08)
+
+
+### Bug Fixes
+
+* **promise:** clear timeout on promise resolution ([6301a6b](https://github.com/medikoo/timers-ext/commit/6301a6b))
+
+
+
+<a name="0.1.3"></a>
+
+## [0.1.3](https://github.com/medikoo/timers-ext/compare/v0.1.2...v0.1.3) (2018-03-07)
+
+### Features
+
+*   **promise:** promise.timeout method ([3f52d27](https://github.com/medikoo/timers-ext/commit/3f52d27))
+
+## Changelog for previous versions
+
+See `CHANGES` file

node_modules/timers-ext/CHANGES

@@ -0,0 +1,26 @@
+For recent changelog see CHANGELOG.md
+
+-----
+
+
+v0.1.2  --  2017.04.03
+* `throttle` util
+
+v0.1.1  --  2017.03.15
+* Workaround IE8 resolution issue
+* Support any callable objects as callbacks
+* Improve documentation
+* Fix spelling of LICENSE
+* Configure lint scripts
+* Update dependencies
+
+v0.1.0  --  2014.04.27
+First production ready version
+- Depend strictly on npm hosted package versions
+- Full documentation
+- Add `once` (moved from next-tick project)
+- Make timeout value optional in delay
+- Rename MAX_VALUE into MAX_TIMEOUT
+
+v0.0.0  --  2013.08.27
+Initial (dev) version

node_modules/timers-ext/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2013-2018, Mariusz Nowak, @medikoo, medikoo.com
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

node_modules/timers-ext/README.md

@@ -0,0 +1,69 @@
+[![Build status][nix-build-image]][nix-build-url]
+[![Windows status][win-build-image]][win-build-url]
+![Transpilation status][transpilation-image]
+[![npm version][npm-image]][npm-url]
+
+# timers-ext
+
+## Timers extensions
+
+### Installation
+
+    $ npm install timers-ext
+
+To port it to Browser or any other (non CJS) environment, use your favorite CJS bundler. No favorite yet? Try: [Browserify](http://browserify.org/), [Webmake](https://github.com/medikoo/modules-webmake) or [Webpack](http://webpack.github.io/)
+
+### API
+
+#### MAX*TIMEOUT *(timers-ext/max-timeout)\_
+
+Maximum possible timeout value in milliseconds. It equals to maximum positive value for 32bit signed integer, so _2³¹ (2147483647)_, which makes it around 24.9 days
+
+#### delay(fn[, timeout]) _(timers-ext/delay)_
+
+Returns function which when invoked will call _fn_ function after specified
+_timeout_. If _timeout_ is not provided [nextTick](https://github.com/medikoo/next-tick/#next-tick) propagation is used.
+
+#### once(fn[, timeout]) _(timers-ext/once)_
+
+Makes sure to execute _fn_ function only once after a defined interval of time (debounce). If _timeout_ is not provided [nextTick](https://github.com/medikoo/next-tick/#next-tick) propagation is used.
+
+```javascript
+var nextTick = require("next-tick");
+var logFoo = function() {
+	console.log("foo");
+};
+var logFooOnce = require("timers-ext/once")(logFoo);
+
+logFooOnce();
+logFooOnce(); // ignored, logFoo will be logged only once
+logFooOnce(); // ignored
+
+nextTick(function() {
+	logFooOnce(); // Invokes another log (as tick passed)
+	logFooOnce(); // ignored
+	logFooOnce(); // ignored
+});
+```
+
+#### validTimeout(timeout) _(timers-ext/valid-timeout)_
+
+Validates timeout value.  
+For `NaN` resolved _timeout_ `0` is returned.
+If _timeout_ resolves to a number:
+
+-   for _timeout < 0_ `0` is returned
+-   for _0 >= timeout <= [MAX_TIMEOUT](#max_timeout-timers-extmax-timeout)_, `timeout` value is returned
+-   for _timeout > [MAX_TIMEOUT](#max_timeout-timers-extmax-timeout)_ exception is thrown
+
+### Tests
+
+    $ npm test
+
+[nix-build-image]: https://semaphoreci.com/api/v1/medikoo-org/timers-ext/branches/master/shields_badge.svg
+[nix-build-url]: https://semaphoreci.com/medikoo-org/timers-ext
+[win-build-image]: https://ci.appveyor.com/api/projects/status/2i5nerowov2ho3o9?svg=true
+[win-build-url]: https://ci.appveyor.com/project/medikoo/timers-ext
+[transpilation-image]: https://img.shields.io/badge/transpilation-free-brightgreen.svg
+[npm-image]: https://img.shields.io/npm/v/timers-ext.svg
+[npm-url]: https://www.npmjs.com/package/timers-ext

node_modules/timers-ext/delay.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var callable     = require("es5-ext/object/valid-callable")
+  , nextTick     = require("next-tick")
+  , validTimeout = require("./valid-timeout");
+
+var apply = Function.prototype.apply;
+
+module.exports = function (fn/*, timeout*/) {
+	var delay, timeout = arguments[1];
+	callable(fn);
+	if (timeout === undefined) {
+		delay = nextTick;
+	} else {
+		timeout = validTimeout(timeout);
+		delay = setTimeout;
+	}
+	return function () {
+		return delay(apply.bind(fn, this, arguments), timeout);
+	};
+};

node_modules/timers-ext/max-timeout.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = 2147483647;

node_modules/timers-ext/once.js

@@ -0,0 +1,42 @@
+// It's actually "debounce"
+
+"use strict";
+
+var isValue      = require("es5-ext/object/is-value")
+  , callable     = require("es5-ext/object/valid-callable")
+  , nextTick     = require("next-tick")
+  , validTimeout = require("./valid-timeout");
+
+var apply = Function.prototype.apply;
+
+module.exports = function (fn/*, timeout*/) {
+	var scheduled, run, context, args, delay, timeout = arguments[1], handle;
+	callable(fn);
+	if (isValue(timeout)) {
+		timeout = validTimeout(timeout);
+		delay = setTimeout;
+	} else {
+		delay = nextTick;
+	}
+	run = function () {
+		if (!scheduled) return; // IE8 tends to not clear immediate timeouts properly
+		scheduled = false;
+		handle = null;
+		apply.call(fn, context, args);
+		context = null;
+		args = null;
+	};
+	return function () {
+		if (scheduled) {
+			if (!isValue(handle)) {
+				// 'nextTick' based, no room for debounce
+				return;
+			}
+			clearTimeout(handle);
+		}
+		scheduled = true;
+		context = this;
+		args = arguments;
+		handle = delay(run, timeout);
+	};
+};

node_modules/timers-ext/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "timers-ext",
+  "version": "0.1.7",
+  "description": "Timers extensions",
+  "author": "Mariusz Nowak <medyk@medikoo.com> (http://www.medikoo.com/)",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/timers-ext.git"
+  },
+  "keywords": [
+    "timeout",
+    "delay",
+    "interval",
+    "time",
+    "timer",
+    "timers"
+  ],
+  "dependencies": {
+    "es5-ext": "~0.10.46",
+    "next-tick": "1"
+  },
+  "devDependencies": {
+    "eslint": "^5.6.1",
+    "eslint-config-medikoo-es5": "^1.7.2",
+    "tad": "^0.2.8"
+  },
+  "eslintConfig": {
+    "extends": "medikoo-es5",
+    "root": true,
+    "globals": {
+      "clearInterval": true,
+      "clearTimeout": true,
+      "setInterval": true,
+      "setTimeout": true
+    }
+  },
+  "scripts": {
+    "lint": "eslint --ignore-path=.gitignore .",
+    "test": "node node_modules/tad/bin/tad"
+  },
+  "license": "ISC"
+}

node_modules/timers-ext/promise/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+	"globals": { "Promise": true }
+}

node_modules/timers-ext/promise/sleep.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var isValue       = require("es5-ext/object/is-value")
+  , isPromise     = require("es5-ext/object/is-promise")
+  , nextTick      = require("next-tick")
+  , ensureTimeout = require("../valid-timeout");
+
+module.exports = function (/* timeout */) {
+	var Constructor = isPromise(this) ? this.constructor : Promise;
+	var timeout = arguments[0];
+	if (isValue(timeout)) timeout = ensureTimeout(timeout);
+	return new Constructor(function (resolve) {
+		if (isValue(timeout)) {
+			setTimeout(function () {
+				resolve();
+			}, timeout);
+		} else {
+			nextTick(resolve);
+		}
+	});
+};

node_modules/timers-ext/promise_/timeout.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var customError   = require("es5-ext/error/custom")
+  , isValue       = require("es5-ext/object/is-value")
+  , ensurePromise = require("es5-ext/object/ensure-promise")
+  , nextTick      = require("next-tick")
+  , ensureTimeout = require("../valid-timeout");
+
+module.exports = function (/* timeout */) {
+	ensurePromise(this);
+	var timeout = arguments[0];
+	if (isValue(timeout)) timeout = ensureTimeout(timeout);
+	return new this.constructor(
+		function (resolve, reject) {
+			var isSettled = false, timeoutId;
+			var timeoutCallback = function () {
+				if (isSettled) return;
+				reject(
+					customError(
+						"Operation timeout (exceeded " +
+							(isValue(timeout) ? timeout + "ms" : "tick") +
+							")",
+						"PROMISE_TIMEOUT"
+					)
+				);
+			};
+			if (isValue(timeout)) timeoutId = setTimeout(timeoutCallback, timeout);
+			else nextTick(timeoutCallback);
+			this.then(
+				function (value) {
+					isSettled = true;
+					clearTimeout(timeoutId);
+					resolve(value);
+				},
+				function (reason) {
+					isSettled = true;
+					clearTimeout(timeoutId);
+					reject(reason);
+				}
+			);
+		}.bind(this)
+	);
+};

node_modules/timers-ext/test/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+	"rules": {
+		"id-length": "off",
+		"no-shadow": "off"
+	}
+}

node_modules/timers-ext/test/delay.js

@@ -0,0 +1,27 @@
+"use strict";
+
+module.exports = function (t, a, d) {
+	var data
+	  , count = 0
+	  , x = function (a, b, c) {
+			data = [this, a, b, c, ++count];
+		}
+	  , y = t(x, 200)
+	  , z = {};
+
+	a(data, undefined, "Setup");
+	y.call(z, 111, "foo", false);
+	a(data, undefined, "Immediately");
+	setTimeout(function () {
+		a(data, undefined, "100ms");
+		setTimeout(function () {
+			a.deep(data, [z, 111, "foo", false, 1], "250ms");
+			data = null;
+			clearTimeout(y());
+			setTimeout(function () {
+				a(data, null, "Clear");
+				d();
+			}, 300);
+		}, 150);
+	}, 100);
+};

node_modules/timers-ext/test/max-timeout.js

@@ -0,0 +1,13 @@
+"use strict";
+
+module.exports = function (t, a, d) {
+	var invoked, id;
+	id = setTimeout(function () {
+ invoked = true;
+}, t);
+	setTimeout(function () {
+		a(invoked, undefined);
+		clearTimeout(id);
+		d();
+	}, 100);
+};

node_modules/timers-ext/test/once.js

@@ -0,0 +1,42 @@
+"use strict";
+
+module.exports = function (t, a, d) {
+	var called = 0, fn = t(function () {
+ ++called;
+});
+
+	fn();
+	fn();
+	fn();
+	setTimeout(function () {
+		a(called, 1);
+
+		called = 0;
+		fn = t(function () {
+ ++called;
+}, 50);
+		fn();
+		fn();
+		fn();
+
+		setTimeout(function () {
+			fn();
+			fn();
+
+			setTimeout(function () {
+				fn();
+				fn();
+
+				setTimeout(function () {
+					fn();
+					fn();
+
+					setTimeout(function () {
+						a(called, 1);
+						d();
+					}, 70);
+				}, 30);
+			}, 30);
+		}, 30);
+	}, 10);
+};

node_modules/timers-ext/test/promise/sleep.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var delay = require("../../delay");
+
+module.exports = function (t, a) {
+	if (typeof Promise !== "function") return null;
+	return {
+		Tick: function (d) {
+			var isInvoked = false;
+			t().then(function (result) {
+				isInvoked = true;
+				delay(function () {
+					a(result, undefined);
+					d();
+				})();
+			}, delay(d));
+			a(isInvoked, false);
+		},
+		Timeout: function (d) {
+			var isInvoked = false;
+			t(100).then(
+				delay(function (result) {
+					isInvoked = true;
+					a(result, undefined);
+					d();
+				}),
+				delay(d)
+			);
+			setTimeout(function () {
+				a(isInvoked, false);
+			}, 50);
+		}
+	};
+};

node_modules/timers-ext/test/promise_/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+	"globals": { "Promise": true }
+}

node_modules/timers-ext/test/promise_/timeout.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var delay = require("../../delay");
+
+module.exports = function (t, a) {
+	if (typeof Promise !== "function") return null;
+	return {
+		Success: function (d) {
+			var promise = t.call(
+				new Promise(function (resolve) {
+					setTimeout(function () { resolve("foo"); }, 20);
+				}),
+				40
+			);
+
+			promise.then(
+				// Delay to escape error swallowing
+				delay(function (result) {
+					a(result, "foo");
+					d();
+				}),
+				delay(d)
+			);
+		},
+		Timeout: function (d) {
+			var promise = t.call(
+				new Promise(function (resolve) {
+					setTimeout(function () { resolve("foo"); }, 40);
+				}),
+				20
+			);
+
+			promise.then(
+				// Delay to escape error swallowing
+				delay(function () {
+					a.never();
+					d();
+				}),
+				delay(function (err) {
+					a(err.code, "PROMISE_TIMEOUT");
+					d();
+				})
+			);
+		}
+	};
+};

node_modules/timers-ext/test/throttle.js

@@ -0,0 +1,41 @@
+"use strict";
+
+module.exports = function (t, a, d) {
+	var called = 0;
+	var fn = t(function () {
+		++called;
+	}, 200);
+
+	fn();
+	a(called, 1);
+	fn();
+	fn();
+	a(called, 1);
+	// Wait 120ms
+	setTimeout(function () {
+		a(called, 1);
+		fn();
+		// Wait 120ms
+		setTimeout(function () {
+			a(called, 2);
+			fn();
+			fn();
+
+			// Wait 80ms
+			setTimeout(function () {
+				a(called, 2);
+
+				// Wait 120ms
+				setTimeout(function () {
+					a(called, 3);
+
+					// Wait 400ms
+					setTimeout(function () {
+						a(called, 3);
+						d();
+					}, 400);
+				}, 120);
+			}, 80);
+		}, 120);
+	}, 120);
+};

node_modules/timers-ext/test/valid-timeout.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = function (t, a) {
+	a(t(NaN), 0, "NaN");
+	a(t(-343), 0, "Negative");
+	a(t(232342), 232342, "Positive");
+	a.throws(function () {
+ t(1e23);
+}, TypeError, "Too large");
+};

node_modules/timers-ext/throttle.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var callable     = require("es5-ext/object/valid-callable")
+  , validTimeout = require("./valid-timeout")
+
+  , apply = Function.prototype.apply;
+
+module.exports = function (fn, timeout) {
+	var isScheduled = false, context, args, run;
+	callable(fn);
+	timeout = validTimeout(timeout);
+	run = function () {
+		var currentContext = context, currentArgs = args;
+		if (!args) {
+			isScheduled = false;
+			return;
+		}
+		context = null;
+		args = null;
+		setTimeout(run, timeout);
+		apply.call(fn, currentContext, currentArgs);
+	};
+	return function () {
+		if (isScheduled) {
+			context = this;
+			args = arguments;
+			return;
+		}
+		isScheduled = true;
+		setTimeout(run, timeout);
+		apply.call(fn, this, arguments);
+	};
+};

node_modules/timers-ext/valid-timeout.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var toPosInt   = require("es5-ext/number/to-pos-integer")
+  , maxTimeout = require("./max-timeout");
+
+module.exports = function (value) {
+	value = toPosInt(value);
+	if (value > maxTimeout) throw new TypeError(value + " exceeds maximum possible timeout");
+	return value;
+};