extra-game-loop 0.1.2 → 0.1.3

package/dist/es2015/index.mjs

@@ -1,6 +1,6 @@
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$e = {};
+var es2018$f = {};
 
 var box = {};
 
@@ -23,7 +23,7 @@ box.Box = Box;
 
 var cons = {};
 
-var es2018$d = {};
+var es2018$e = {};
 
 var array$2 = {};
 
@@ -635,10 +635,10 @@ regexp$2.isntRegExp = isntRegExp$2;
 	__exportStar(url$2, exports);
 	__exportStar(regexp$2, exports);
 	
-} (es2018$d));
+} (es2018$e));
 
 cons.convertArrayToCons = cons.convertConsToArray = void 0;
-const types_1$X = es2018$d;
+const types_1$X = es2018$e;
 function convertConsToArray([value, next]) {
     if ((0, types_1$X.isNull)(next)) {
         return [value];
@@ -799,17 +799,17 @@ queue$1.Queue = Queue;
 
 var lruMap = {};
 
-var es2018$c = {};
+var es2018$d = {};
 
 var customError = {};
 
-var es2018$b = {};
+var es2018$c = {};
 
 var middleware$2 = {};
 
 var chunkAsync$4 = {};
 
-var es2018$a = {};
+var es2018$b = {};
 
 var go$1 = {};
 
@@ -838,11 +838,11 @@ goMicrotask$1.goMicrotask = goMicrotask;
 
 var goMacrotask$1 = {};
 
-var es2018$9 = {};
+var es2018$a = {};
 
 var exponentialBackoff = {};
 
-var es2018$8 = {};
+var es2018$9 = {};
 
 var random$1 = {};
 
@@ -886,10 +886,10 @@ randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
 	__exportStar(randomInt$1, exports);
 	__exportStar(randomIntInclusive$1, exports);
 	
-} (es2018$8));
+} (es2018$9));
 
 exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-const extra_rand_1 = es2018$8;
+const extra_rand_1 = es2018$9;
 function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
     const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
     if (jitter) {
@@ -1004,10 +1004,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	__exportStar(setTimeoutLoop$1, exports);
 	__exportStar(setDynamicTimeoutLoop$1, exports);
 	
-} (es2018$9));
+} (es2018$a));
 
 goMacrotask$1.goMacrotask = void 0;
-const extra_timers_1$2 = es2018$9;
+const extra_timers_1$2 = es2018$a;
 function goMacrotask(fn) {
     return new Promise((resolve, reject) => {
         (0, extra_timers_1$2.setImmediate)(async () => {
@@ -1040,7 +1040,7 @@ goMacrotask$1.goMacrotask = goMacrotask;
 	__exportStar(goMicrotask$1, exports);
 	__exportStar(goMacrotask$1, exports);
 	
-} (es2018$a));
+} (es2018$b));
 
 var hasRequiredChunkAsync;
 
@@ -1048,7 +1048,7 @@ function requireChunkAsync () {
 	if (hasRequiredChunkAsync) return chunkAsync$4;
 	hasRequiredChunkAsync = 1;
 chunkAsync$4.chunkAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function chunkAsync(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1074,7 +1074,7 @@ chunkAsync$4.chunkAsync = void 0;
 var chunkByAsync$5 = {};
 
 chunkByAsync$5.chunkByAsync = void 0;
-const types_1$W = es2018$d;
+const types_1$W = es2018$e;
 function chunkByAsync$4(iterable, predicate) {
     if ((0, types_1$W.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable$2(iterable, predicate);
@@ -1140,7 +1140,7 @@ function requireChunk () {
 	if (hasRequiredChunk) return chunk$4;
 	hasRequiredChunk = 1;
 chunk$4.chunk = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function chunk(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1166,8 +1166,8 @@ chunk$4.chunk = void 0;
 var concatAsync$5 = {};
 
 concatAsync$5.concatAsync = void 0;
-const types_1$V = es2018$d;
-const go_1$x = es2018$a;
+const types_1$V = es2018$e;
+const go_1$x = es2018$b;
 function concatAsync$4(iterable, ...otherIterables) {
     return (0, go_1$x.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1189,7 +1189,7 @@ concatAsync$5.concatAsync = concatAsync$4;
 var concat$9 = {};
 
 concat$9.concat = void 0;
-const go_1$w = es2018$a;
+const go_1$w = es2018$b;
 function concat$8(iterable, ...otherIterables) {
     return (0, go_1$w.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1223,7 +1223,7 @@ function requireDropAsync () {
 	if (hasRequiredDropAsync) return dropAsync$4;
 	hasRequiredDropAsync = 1;
 dropAsync$4.dropAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropAsync(iterable, count) {
@@ -1266,7 +1266,7 @@ function requireDropRightAsync () {
 	if (hasRequiredDropRightAsync) return dropRightAsync$4;
 	hasRequiredDropRightAsync = 1;
 dropRightAsync$4.dropRightAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropRightAsync(iterable, count) {
@@ -1302,7 +1302,7 @@ function requireDropRight () {
 	if (hasRequiredDropRight) return dropRight$4;
 	hasRequiredDropRight = 1;
 dropRight$4.dropRight = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropRight(iterable, count) {
@@ -1323,7 +1323,7 @@ dropRight$4.dropRight = void 0;
 var dropUntilAsync$5 = {};
 
 dropUntilAsync$5.dropUntilAsync = void 0;
-const types_1$U = es2018$d;
+const types_1$U = es2018$e;
 function dropUntilAsync$4(iterable, predicate) {
     if ((0, types_1$U.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable$2(iterable, predicate);
@@ -1410,7 +1410,7 @@ function requireDrop () {
 	if (hasRequiredDrop) return drop$4;
 	hasRequiredDrop = 1;
 drop$4.drop = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function drop(iterable, count) {
@@ -1448,7 +1448,7 @@ drop$4.drop = void 0;
 var filterAsync$5 = {};
 
 filterAsync$5.filterAsync = void 0;
-const types_1$T = es2018$d;
+const types_1$T = es2018$e;
 function filterAsync$4(iterable, predicate) {
     if ((0, types_1$T.isAsyncIterable)(iterable)) {
         return filterAsyncIterable$2(iterable, predicate);
@@ -1495,7 +1495,7 @@ var flattenDeepAsync$4 = {};
 var flattenByAsync$5 = {};
 
 flattenByAsync$5.flattenByAsync = void 0;
-const types_1$S = es2018$d;
+const types_1$S = es2018$e;
 function flattenByAsync$4(iterable, predicate) {
     if ((0, types_1$S.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable$2(iterable, predicate);
@@ -1569,7 +1569,7 @@ flattenAsync$4.flattenAsync = void 0;
 var flattenBy$5 = {};
 
 flattenBy$5.flattenBy = void 0;
-const types_1$R = es2018$d;
+const types_1$R = es2018$e;
 function flattenBy$4(iterable, predicate) {
     return flatten$9(iterable, predicate, 1);
 }
@@ -1628,7 +1628,7 @@ flatten$8.flatten = void 0;
 var mapAsync$5 = {};
 
 mapAsync$5.mapAsync = void 0;
-const types_1$Q = es2018$d;
+const types_1$Q = es2018$e;
 function mapAsync$4(iterable, fn) {
     if ((0, types_1$Q.isAsyncIterable)(iterable)) {
         return mapAsyncIterable$2(iterable, fn);
@@ -1673,7 +1673,7 @@ function requireRepeatAsync () {
 	if (hasRequiredRepeatAsync) return repeatAsync$4;
 	hasRequiredRepeatAsync = 1;
 repeatAsync$4.repeatAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function repeatAsync(iterable, times) {
 	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -1716,7 +1716,7 @@ function requireRepeat () {
 	if (hasRequiredRepeat) return repeat$6;
 	hasRequiredRepeat = 1;
 repeat$6.repeat = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function repeat(iterable, times) {
 	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -1759,7 +1759,7 @@ function requireSliceAsync () {
 	if (hasRequiredSliceAsync) return sliceAsync$4;
 	hasRequiredSliceAsync = 1;
 sliceAsync$4.sliceAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function sliceAsync(iterable, start, end = Infinity) {
 	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -1790,7 +1790,7 @@ function requireSlice () {
 	if (hasRequiredSlice) return slice$4;
 	hasRequiredSlice = 1;
 slice$4.slice = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function slice(iterable, start, end = Infinity) {
 	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -1834,7 +1834,7 @@ splitAsync$5.splitAsync = splitAsync$4;
 var splitByAsync$5 = {};
 
 splitByAsync$5.splitByAsync = void 0;
-const types_1$P = es2018$d;
+const types_1$P = es2018$e;
 function splitByAsync$4(iterable, predicate) {
     if ((0, types_1$P.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable$2(iterable, predicate);
@@ -1921,7 +1921,7 @@ function requireTakeAsync () {
 	if (hasRequiredTakeAsync) return takeAsync$4;
 	hasRequiredTakeAsync = 1;
 takeAsync$4.takeAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function takeAsync(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -1950,7 +1950,7 @@ function requireTakeRightAsync () {
 	if (hasRequiredTakeRightAsync) return takeRightAsync$4;
 	hasRequiredTakeRightAsync = 1;
 takeRightAsync$4.takeRightAsync = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function takeRightAsync(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -1988,7 +1988,7 @@ function requireTakeRight () {
 	if (hasRequiredTakeRight) return takeRight$4;
 	hasRequiredTakeRight = 1;
 takeRight$4.takeRight = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function takeRight(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2021,7 +2021,7 @@ takeRight$4.takeRight = void 0;
 var takeUntilAsync$5 = {};
 
 takeUntilAsync$5.takeUntilAsync = void 0;
-const types_1$O = es2018$d;
+const types_1$O = es2018$e;
 function takeUntilAsync$4(iterable, predicate) {
     if ((0, types_1$O.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable$2(iterable, predicate);
@@ -2072,7 +2072,7 @@ function requireTake () {
 	if (hasRequiredTake) return take$6;
 	hasRequiredTake = 1;
 take$6.take = void 0;
-	const go_1 = es2018$a;
+	const go_1 = es2018$b;
 	const errors_1 = requireEs2018();
 	function take(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2096,7 +2096,7 @@ take$6.take = void 0;
 var tapAsync$5 = {};
 
 tapAsync$5.tapAsync = void 0;
-const types_1$N = es2018$d;
+const types_1$N = es2018$e;
 function tapAsync$4(iterable, fn) {
     if ((0, types_1$N.isAsyncIterable)(iterable)) {
         return tapAsyncIterable$2(iterable, fn);
@@ -2179,7 +2179,7 @@ uniqAsync$5.uniqAsync = uniqAsync$4;
 var uniqByAsync$5 = {};
 
 uniqByAsync$5.uniqByAsync = void 0;
-const types_1$M = es2018$d;
+const types_1$M = es2018$e;
 function uniqByAsync$4(iterable, fn) {
     if ((0, types_1$M.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable$2(iterable, fn);
@@ -2248,7 +2248,7 @@ uniq$5.uniq = uniq$4;
 var zipAsync$5 = {};
 
 zipAsync$5.zipAsync = void 0;
-const types_1$L = es2018$d;
+const types_1$L = es2018$e;
 var Kind$2;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2419,7 +2419,7 @@ consume$5.consume = consume$4;
 var eachAsync$5 = {};
 
 eachAsync$5.eachAsync = void 0;
-const types_1$K = es2018$d;
+const types_1$K = es2018$e;
 function eachAsync$4(iterable, fn) {
     if ((0, types_1$K.isAsyncIterable)(iterable)) {
         return eachAsyncIterable$2(iterable, fn);
@@ -2459,7 +2459,7 @@ each$5.each = each$4;
 var everyAsync$5 = {};
 
 everyAsync$5.everyAsync = void 0;
-const types_1$J = es2018$d;
+const types_1$J = es2018$e;
 function everyAsync$4(iterable, predicate) {
     if ((0, types_1$J.isAsyncIterable)(iterable)) {
         return everyAsyncIterable$2(iterable, predicate);
@@ -2505,7 +2505,7 @@ every$7.every = every$6;
 var findAsync$5 = {};
 
 findAsync$5.findAsync = void 0;
-const types_1$I = es2018$d;
+const types_1$I = es2018$e;
 function findAsync$4(iterable, predicate) {
     if ((0, types_1$I.isAsyncIterable)(iterable)) {
         return findAsyncIterable$2(iterable, predicate);
@@ -2629,7 +2629,7 @@ match$5.match = match$4;
 var reduceAsync$5 = {};
 
 reduceAsync$5.reduceAsync = void 0;
-const types_1$H = es2018$d;
+const types_1$H = es2018$e;
 function reduceAsync$4(iterable, fn, initialValue) {
     if ((0, types_1$H.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$2(iterable, fn);
@@ -2725,7 +2725,7 @@ function reduceAsyncWithoutInitialValue$2(iterable, fn) {
 var reduce$7 = {};
 
 reduce$7.reduce = void 0;
-const types_1$G = es2018$d;
+const types_1$G = es2018$e;
 function reduce$6(iterable, fn, initialValue) {
     if ((0, types_1$G.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$2(iterable, fn);
@@ -2772,7 +2772,7 @@ function reduceWithoutInitialValue$2(iterable, fn) {
 var someAsync$5 = {};
 
 someAsync$5.someAsync = void 0;
-const types_1$F = es2018$d;
+const types_1$F = es2018$e;
 function someAsync$4(iterable, predicate) {
     if ((0, types_1$F.isAsyncIterable)(iterable)) {
         return someAsyncIterable$2(iterable, predicate);
@@ -3012,7 +3012,7 @@ groupByAsync$5.groupByAsync = groupByAsync$4;
 var hasRequiredEs2018$1;
 
 function requireEs2018$1 () {
-	if (hasRequiredEs2018$1) return es2018$b;
+	if (hasRequiredEs2018$1) return es2018$c;
 	hasRequiredEs2018$1 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3031,8 +3031,8 @@ function requireEs2018$1 () {
 		};__exportStar(requireMiddleware(), exports);
 		__exportStar(output$2, exports);
 		
-} (es2018$b));
-	return es2018$b;
+} (es2018$c));
+	return es2018$c;
 }
 
 var getErrorNames$1 = {};
@@ -3051,7 +3051,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$E = es2018$d;
+const types_1$E = es2018$e;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -3072,7 +3072,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$D = es2018$d;
+const types_1$D = es2018$e;
 function isSerializableError(val) {
     return (0, types_1$D.isObject)(val)
         && (0, types_1$D.isString)(val.name)
@@ -3090,7 +3090,7 @@ function requireCustomError () {
 customError.CustomError = void 0;
 	const iterable_operator_1 = requireEs2018$1();
 	const get_error_names_1 = getErrorNames$1;
-	const types_1 = es2018$d;
+	const types_1 = es2018$e;
 	const serializable_error_1 = serializableError;
 	class CustomError extends Error {
 	    get name() {
@@ -3160,13 +3160,13 @@ normalize.normalize = void 0;
 
 var hydrate$1 = {};
 
-var es2018$7 = {};
+var es2018$8 = {};
 
-var pass$1 = {};
+var pass$3 = {};
 
-pass$1.pass = void 0;
-function pass() { }
-pass$1.pass = pass;
+pass$3.pass = void 0;
+function pass$2() { }
+pass$3.pass = pass$2;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3178,12 +3178,12 @@ pass$1.pass = pass;
 	}));
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(pass$1, exports);
+	};__exportStar(pass$3, exports);
 	
-} (es2018$7));
+} (es2018$8));
 
 hydrate$1.hydrate = void 0;
-const pass_1 = es2018$7;
+const pass_1 = es2018$8;
 function hydrate(err) {
     var _a;
     const errorNames = [err.name, ...err.ancestors]
@@ -3229,7 +3229,7 @@ assert.assert = void 0;
 var hasRequiredEs2018;
 
 function requireEs2018 () {
-	if (hasRequiredEs2018) return es2018$c;
+	if (hasRequiredEs2018) return es2018$d;
 	hasRequiredEs2018 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3254,18 +3254,18 @@ function requireEs2018 () {
 		__exportStar(getErrorNames$1, exports);
 		__exportStar(traverseErrorPrototypeChain$1, exports);
 		
-} (es2018$c));
-	return es2018$c;
+} (es2018$d));
+	return es2018$d;
 }
 
-var es2018$6 = {};
+var es2018$7 = {};
 
 var middleware$1 = {};
 
 var chunkAsync$3 = {};
 
 chunkAsync$3.chunkAsync = void 0;
-const go_1$v = es2018$a;
+const go_1$v = es2018$b;
 const errors_1$C = requireEs2018();
 function chunkAsync$2(iterable, size) {
     (0, errors_1$C.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -3288,7 +3288,7 @@ chunkAsync$3.chunkAsync = chunkAsync$2;
 var chunkByAsync$3 = {};
 
 chunkByAsync$3.chunkByAsync = void 0;
-const types_1$C = es2018$d;
+const types_1$C = es2018$e;
 function chunkByAsync$2(iterable, predicate) {
     if ((0, types_1$C.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable$1(iterable, predicate);
@@ -3349,7 +3349,7 @@ chunkBy$3.chunkBy = chunkBy$2;
 var chunk$3 = {};
 
 chunk$3.chunk = void 0;
-const go_1$u = es2018$a;
+const go_1$u = es2018$b;
 const errors_1$B = requireEs2018();
 function chunk$2(iterable, size) {
     (0, errors_1$B.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -3372,8 +3372,8 @@ chunk$3.chunk = chunk$2;
 var concatAsync$3 = {};
 
 concatAsync$3.concatAsync = void 0;
-const types_1$B = es2018$d;
-const go_1$t = es2018$a;
+const types_1$B = es2018$e;
+const go_1$t = es2018$b;
 function concatAsync$2(iterable, ...otherIterables) {
     return (0, go_1$t.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3395,7 +3395,7 @@ concatAsync$3.concatAsync = concatAsync$2;
 var concat$7 = {};
 
 concat$7.concat = void 0;
-const go_1$s = es2018$a;
+const go_1$s = es2018$b;
 function concat$6(iterable, ...otherIterables) {
     return (0, go_1$s.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3424,7 +3424,7 @@ function* copyIterable$1(iterable) {
 utils$1.copyIterable = copyIterable$1;
 
 dropAsync$3.dropAsync = void 0;
-const go_1$r = es2018$a;
+const go_1$r = es2018$b;
 const utils_1$7 = utils$1;
 const errors_1$A = requireEs2018();
 function dropAsync$2(iterable, count) {
@@ -3459,7 +3459,7 @@ dropAsync$3.dropAsync = dropAsync$2;
 var dropRightAsync$3 = {};
 
 dropRightAsync$3.dropRightAsync = void 0;
-const go_1$q = es2018$a;
+const go_1$q = es2018$b;
 const utils_1$6 = utils$1;
 const errors_1$z = requireEs2018();
 function dropRightAsync$2(iterable, count) {
@@ -3487,7 +3487,7 @@ async function toArrayAsync$5(iterable) {
 var dropRight$3 = {};
 
 dropRight$3.dropRight = void 0;
-const go_1$p = es2018$a;
+const go_1$p = es2018$b;
 const utils_1$5 = utils$1;
 const errors_1$y = requireEs2018();
 function dropRight$2(iterable, count) {
@@ -3505,7 +3505,7 @@ dropRight$3.dropRight = dropRight$2;
 var dropUntilAsync$3 = {};
 
 dropUntilAsync$3.dropUntilAsync = void 0;
-const types_1$A = es2018$d;
+const types_1$A = es2018$e;
 function dropUntilAsync$2(iterable, predicate) {
     if ((0, types_1$A.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable$1(iterable, predicate);
@@ -3587,7 +3587,7 @@ dropUntil$3.dropUntil = dropUntil$2;
 var drop$3 = {};
 
 drop$3.drop = void 0;
-const go_1$o = es2018$a;
+const go_1$o = es2018$b;
 const utils_1$4 = utils$1;
 const errors_1$x = requireEs2018();
 function drop$2(iterable, count) {
@@ -3622,7 +3622,7 @@ drop$3.drop = drop$2;
 var filterAsync$3 = {};
 
 filterAsync$3.filterAsync = void 0;
-const types_1$z = es2018$d;
+const types_1$z = es2018$e;
 function filterAsync$2(iterable, predicate) {
     if ((0, types_1$z.isAsyncIterable)(iterable)) {
         return filterAsyncIterable$1(iterable, predicate);
@@ -3669,7 +3669,7 @@ var flattenDeepAsync$3 = {};
 var flattenByAsync$3 = {};
 
 flattenByAsync$3.flattenByAsync = void 0;
-const types_1$y = es2018$d;
+const types_1$y = es2018$e;
 function flattenByAsync$2(iterable, predicate) {
     if ((0, types_1$y.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable$1(iterable, predicate);
@@ -3727,7 +3727,7 @@ flattenAsync$3.flattenAsync = flattenAsync$2;
 var flattenBy$3 = {};
 
 flattenBy$3.flattenBy = void 0;
-const types_1$x = es2018$d;
+const types_1$x = es2018$e;
 function flattenBy$2(iterable, predicate) {
     return flatten$6(iterable, predicate, 1);
 }
@@ -3770,7 +3770,7 @@ flatten$5.flatten = flatten$4;
 var mapAsync$3 = {};
 
 mapAsync$3.mapAsync = void 0;
-const types_1$w = es2018$d;
+const types_1$w = es2018$e;
 function mapAsync$2(iterable, fn) {
     if ((0, types_1$w.isAsyncIterable)(iterable)) {
         return mapAsyncIterable$1(iterable, fn);
@@ -3810,7 +3810,7 @@ map$5.map = map$4;
 var repeatAsync$3 = {};
 
 repeatAsync$3.repeatAsync = void 0;
-const go_1$n = es2018$a;
+const go_1$n = es2018$b;
 const errors_1$u = requireEs2018();
 function repeatAsync$2(iterable, times) {
     (0, errors_1$u.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -3845,7 +3845,7 @@ function isProduction$3() {
 var repeat$5 = {};
 
 repeat$5.repeat = void 0;
-const go_1$m = es2018$a;
+const go_1$m = es2018$b;
 const errors_1$t = requireEs2018();
 function repeat$4(iterable, times) {
     (0, errors_1$t.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -3880,7 +3880,7 @@ function isProduction$2() {
 var sliceAsync$3 = {};
 
 sliceAsync$3.sliceAsync = void 0;
-const go_1$l = es2018$a;
+const go_1$l = es2018$b;
 const errors_1$s = requireEs2018();
 function sliceAsync$2(iterable, start, end = Infinity) {
     (0, errors_1$s.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -3903,7 +3903,7 @@ sliceAsync$3.sliceAsync = sliceAsync$2;
 var slice$3 = {};
 
 slice$3.slice = void 0;
-const go_1$k = es2018$a;
+const go_1$k = es2018$b;
 const errors_1$r = requireEs2018();
 function slice$2(iterable, start, end = Infinity) {
     (0, errors_1$r.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -3944,7 +3944,7 @@ splitAsync$3.splitAsync = splitAsync$2;
 var splitByAsync$3 = {};
 
 splitByAsync$3.splitByAsync = void 0;
-const types_1$v = es2018$d;
+const types_1$v = es2018$e;
 function splitByAsync$2(iterable, predicate) {
     if ((0, types_1$v.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable$1(iterable, predicate);
@@ -4026,7 +4026,7 @@ split$3.split = split$2;
 var takeAsync$3 = {};
 
 takeAsync$3.takeAsync = void 0;
-const go_1$j = es2018$a;
+const go_1$j = es2018$b;
 const errors_1$q = requireEs2018();
 function takeAsync$2(iterable, count) {
     (0, errors_1$q.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4047,7 +4047,7 @@ takeAsync$3.takeAsync = takeAsync$2;
 var takeRightAsync$3 = {};
 
 takeRightAsync$3.takeRightAsync = void 0;
-const go_1$i = es2018$a;
+const go_1$i = es2018$b;
 const errors_1$p = requireEs2018();
 function takeRightAsync$2(iterable, count) {
     (0, errors_1$p.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4077,7 +4077,7 @@ takeRightAsync$3.takeRightAsync = takeRightAsync$2;
 var takeRight$3 = {};
 
 takeRight$3.takeRight = void 0;
-const go_1$h = es2018$a;
+const go_1$h = es2018$b;
 const errors_1$o = requireEs2018();
 function takeRight$2(iterable, count) {
     (0, errors_1$o.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4107,7 +4107,7 @@ takeRight$3.takeRight = takeRight$2;
 var takeUntilAsync$3 = {};
 
 takeUntilAsync$3.takeUntilAsync = void 0;
-const types_1$u = es2018$d;
+const types_1$u = es2018$e;
 function takeUntilAsync$2(iterable, predicate) {
     if ((0, types_1$u.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable$1(iterable, predicate);
@@ -4153,7 +4153,7 @@ takeUntil$5.takeUntil = takeUntil$4;
 var take$5 = {};
 
 take$5.take = void 0;
-const go_1$g = es2018$a;
+const go_1$g = es2018$b;
 const errors_1$n = requireEs2018();
 function take$4(iterable, count) {
     (0, errors_1$n.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4174,7 +4174,7 @@ take$5.take = take$4;
 var tapAsync$3 = {};
 
 tapAsync$3.tapAsync = void 0;
-const types_1$t = es2018$d;
+const types_1$t = es2018$e;
 function tapAsync$2(iterable, fn) {
     if ((0, types_1$t.isAsyncIterable)(iterable)) {
         return tapAsyncIterable$1(iterable, fn);
@@ -4257,7 +4257,7 @@ uniqAsync$3.uniqAsync = uniqAsync$2;
 var uniqByAsync$3 = {};
 
 uniqByAsync$3.uniqByAsync = void 0;
-const types_1$s = es2018$d;
+const types_1$s = es2018$e;
 function uniqByAsync$2(iterable, fn) {
     if ((0, types_1$s.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable$1(iterable, fn);
@@ -4326,7 +4326,7 @@ uniq$3.uniq = uniq$2;
 var zipAsync$3 = {};
 
 zipAsync$3.zipAsync = void 0;
-const types_1$r = es2018$d;
+const types_1$r = es2018$e;
 var Kind$1;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -4490,7 +4490,7 @@ consume$3.consume = consume$2;
 var eachAsync$3 = {};
 
 eachAsync$3.eachAsync = void 0;
-const types_1$q = es2018$d;
+const types_1$q = es2018$e;
 function eachAsync$2(iterable, fn) {
     if ((0, types_1$q.isAsyncIterable)(iterable)) {
         return eachAsyncIterable$1(iterable, fn);
@@ -4530,7 +4530,7 @@ each$3.each = each$2;
 var everyAsync$3 = {};
 
 everyAsync$3.everyAsync = void 0;
-const types_1$p = es2018$d;
+const types_1$p = es2018$e;
 function everyAsync$2(iterable, predicate) {
     if ((0, types_1$p.isAsyncIterable)(iterable)) {
         return everyAsyncIterable$1(iterable, predicate);
@@ -4576,7 +4576,7 @@ every$5.every = every$4;
 var findAsync$3 = {};
 
 findAsync$3.findAsync = void 0;
-const types_1$o = es2018$d;
+const types_1$o = es2018$e;
 function findAsync$2(iterable, predicate) {
     if ((0, types_1$o.isAsyncIterable)(iterable)) {
         return findAsyncIterable$1(iterable, predicate);
@@ -4700,7 +4700,7 @@ match$3.match = match$2;
 var reduceAsync$3 = {};
 
 reduceAsync$3.reduceAsync = void 0;
-const types_1$n = es2018$d;
+const types_1$n = es2018$e;
 function reduceAsync$2(iterable, fn, initialValue) {
     if ((0, types_1$n.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$1(iterable, fn);
@@ -4796,7 +4796,7 @@ function reduceAsyncWithoutInitialValue$1(iterable, fn) {
 var reduce$5 = {};
 
 reduce$5.reduce = void 0;
-const types_1$m = es2018$d;
+const types_1$m = es2018$e;
 function reduce$4(iterable, fn, initialValue) {
     if ((0, types_1$m.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$1(iterable, fn);
@@ -4843,7 +4843,7 @@ function reduceWithoutInitialValue$1(iterable, fn) {
 var someAsync$3 = {};
 
 someAsync$3.someAsync = void 0;
-const types_1$l = es2018$d;
+const types_1$l = es2018$e;
 function someAsync$2(iterable, predicate) {
     if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return someAsyncIterable$1(iterable, predicate);
@@ -5097,11 +5097,11 @@ groupByAsync$3.groupByAsync = groupByAsync$2;
 	};__exportStar(middleware$1, exports);
 	__exportStar(output$1, exports);
 	
-} (es2018$6));
+} (es2018$7));
 
 lruMap.LRUMap = void 0;
 const errors_1$m = requireEs2018();
-const iterable_operator_1$3 = es2018$6;
+const iterable_operator_1$3 = es2018$7;
 class LRUMap {
     constructor(limit) {
         this.map = new Map();
@@ -5156,7 +5156,7 @@ lruMap.LRUMap = LRUMap;
 var expirableMap = {};
 
 expirableMap.ExpirableMap = void 0;
-const extra_timers_1$1 = es2018$9;
+const extra_timers_1$1 = es2018$a;
 class ExpirableMap {
     constructor() {
         this.map = new Map();
@@ -5253,8 +5253,8 @@ var tlruMap = {};
 
 tlruMap.TLRUMap = void 0;
 const errors_1$l = requireEs2018();
-const iterable_operator_1$2 = es2018$6;
-const extra_timers_1 = es2018$9;
+const iterable_operator_1$2 = es2018$7;
+const extra_timers_1 = es2018$a;
 class TLRUMap {
     constructor(limit) {
         this.map = new Map();
@@ -5376,8 +5376,8 @@ tlruMap.TLRUMap = TLRUMap;
 var trieMap = {};
 
 trieMap.TrieMap = void 0;
-const iterable_operator_1$1 = es2018$6;
-const types_1$k = es2018$d;
+const iterable_operator_1$1 = es2018$7;
+const types_1$k = es2018$e;
 class TrieNode {
     constructor(value) {
         this.value = value;
@@ -12910,7 +12910,7 @@ zipWith$1.zipWith = zipWith;
 exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
 	const finite_state_machine_1 = finiteStateMachine;
 	const rxjs_1 = cjs;
-	const types_1 = es2018$d;
+	const types_1 = es2018$e;
 	class ObservableFiniteStateMachine extends finite_state_machine_1.FiniteStateMachine {
 	    constructor() {
 	        super(...arguments);
@@ -13329,7 +13329,7 @@ var sortedSet = {};
 var skipList = {};
 
 skipList.SkipList = skipList.SkipListNode = void 0;
-const types_1$j = es2018$d;
+const types_1$j = es2018$e;
 class SkipListNode {
     constructor(value) {
         this.value = value;
@@ -13483,7 +13483,7 @@ skipList.SkipList = SkipList;
 
 sortedSet.SortedSet = void 0;
 const skip_list_1 = skipList;
-const iterable_operator_1 = es2018$6;
+const iterable_operator_1 = es2018$7;
 class SortedSet {
     constructor(compare) {
         this.skipList = new skip_list_1.SkipList(compare);
@@ -13736,11 +13736,11 @@ typedBitSet.TypedBitSet = TypedBitSet;
 	__exportStar(bitSet, exports);
 	__exportStar(typedBitSet, exports);
 	
-} (es2018$e));
+} (es2018$f));
 
-var es2018$5 = {};
+var es2018$6 = {};
 
-var es2018$4 = {};
+var es2018$5 = {};
 
 var log$1 = {};
 
@@ -13767,7 +13767,7 @@ highResolutionTimestamp_browser.elapsed = elapsed;
 
 time$1.time = void 0;
 const high_resolution_timestamp_1$2 = highResolutionTimestamp_browser;
-const types_1$i = es2018$d;
+const types_1$i = es2018$e;
 function time(message, fn) {
     const startTime = (0, high_resolution_timestamp_1$2.now)();
     const result = fn();
@@ -13835,9 +13835,9 @@ timeAsyncFunction$1.timeAsyncFunction = timeAsyncFunction;
 	__exportStar(timeFunction$1, exports);
 	__exportStar(timeAsyncFunction$1, exports);
 	
-} (es2018$4));
+} (es2018$5));
 
-var es2018$3 = {};
+var es2018$4 = {};
 
 var lazy$1 = {};
 
@@ -13949,6 +13949,35 @@ lazyStatic$1.lazyStatic = lazyStatic;
 	__exportStar(lazyAsyncFunction$1, exports);
 	__exportStar(lazyStatic$1, exports);
 	
+} (es2018$4));
+
+var es2018$3 = {};
+
+var pass$1 = {};
+
+pass$1.pass = void 0;
+function pass() { }
+pass$1.pass = pass;
+
+var passAsync$1 = {};
+
+passAsync$1.passAsync = void 0;
+async function passAsync() { }
+passAsync$1.passAsync = passAsync;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};__exportStar(pass$1, exports);
+	__exportStar(passAsync$1, exports);
+	
 } (es2018$3));
 
 var es2018$2 = {};
@@ -13958,7 +13987,7 @@ var middleware = {};
 var chunkAsync$1 = {};
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$a;
+const go_1$f = es2018$b;
 const errors_1$f = requireEs2018();
 function chunkAsync(iterable, size) {
     (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -14415,7 +14444,7 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$a;
+const go_1$e = es2018$b;
 const errors_1$e = requireEs2018();
 function chunk(iterable, size) {
     (0, errors_1$e.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -14439,7 +14468,7 @@ var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
 const types_1$g = es2018$1;
-const go_1$d = es2018$a;
+const go_1$d = es2018$b;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -14461,7 +14490,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$a;
+const go_1$c = es2018$b;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -14490,7 +14519,7 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$a;
+const go_1$b = es2018$b;
 const utils_1$3 = utils;
 const errors_1$d = requireEs2018();
 function dropAsync(iterable, count) {
@@ -14525,7 +14554,7 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$a;
+const go_1$a = es2018$b;
 const utils_1$2 = utils;
 const errors_1$c = requireEs2018();
 function dropRightAsync(iterable, count) {
@@ -14553,7 +14582,7 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$a;
+const go_1$9 = es2018$b;
 const utils_1$1 = utils;
 const errors_1$b = requireEs2018();
 function dropRight(iterable, count) {
@@ -14653,7 +14682,7 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$a;
+const go_1$8 = es2018$b;
 const utils_1 = utils;
 const errors_1$a = requireEs2018();
 function drop(iterable, count) {
@@ -14876,7 +14905,7 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$a;
+const go_1$7 = es2018$b;
 const errors_1$7 = requireEs2018();
 function repeatAsync(iterable, times) {
     (0, errors_1$7.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -14911,7 +14940,7 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$a;
+const go_1$6 = es2018$b;
 const errors_1$6 = requireEs2018();
 function repeat(iterable, times) {
     (0, errors_1$6.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -14946,7 +14975,7 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$a;
+const go_1$5 = es2018$b;
 const errors_1$5 = requireEs2018();
 function sliceAsync(iterable, start, end = Infinity) {
     (0, errors_1$5.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -14969,7 +14998,7 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$a;
+const go_1$4 = es2018$b;
 const errors_1$4 = requireEs2018();
 function slice(iterable, start, end = Infinity) {
     (0, errors_1$4.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -15092,7 +15121,7 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$a;
+const go_1$3 = es2018$b;
 const errors_1$3 = requireEs2018();
 function takeAsync(iterable, count) {
     (0, errors_1$3.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15113,7 +15142,7 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$a;
+const go_1$2 = es2018$b;
 const errors_1$2 = requireEs2018();
 function takeRightAsync(iterable, count) {
     (0, errors_1$2.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15143,7 +15172,7 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$a;
+const go_1$1 = es2018$b;
 const errors_1$1 = requireEs2018();
 function takeRight(iterable, count) {
     (0, errors_1$1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15219,7 +15248,7 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$a;
+const go_1 = es2018$b;
 const errors_1 = requireEs2018();
 function take(iterable, count) {
     (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -16556,13 +16585,13 @@ exports.isntNumber = exports.isntNull = exports.isntJson = exports.isntIterable
 	exports.isntSymbol = exports.isntRegExp = exports.isntUndefined = exports.isntString = exports.isntPromiseLike = exports.isntPromise = exports.isntPlainObject = exports.isntObject = void 0;
 	var errors_1 = requireEs2018();
 	Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return errors_1.assert; } });
-	var go_1 = es2018$a;
+	var go_1 = es2018$b;
 	Object.defineProperty(exports, "go", { enumerable: true, get: function () { return go_1.go; } });
-	var log_1 = es2018$4;
+	var log_1 = es2018$5;
 	Object.defineProperty(exports, "log", { enumerable: true, get: function () { return log_1.log; } });
-	var extra_lazy_1 = es2018$3;
+	var extra_lazy_1 = es2018$4;
 	Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return extra_lazy_1.lazy; } });
-	var pass_1 = es2018$7;
+	var pass_1 = es2018$3;
 	Object.defineProperty(exports, "pass", { enumerable: true, get: function () { return pass_1.pass; } });
 	var iterable_operator_1 = es2018$2;
 	Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return iterable_operator_1.toArray; } });
@@ -16620,7 +16649,7 @@ exports.isntNumber = exports.isntNull = exports.isntJson = exports.isntIterable
 	Object.defineProperty(exports, "isntRegExp", { enumerable: true, get: function () { return types_1.isntRegExp; } });
 	Object.defineProperty(exports, "isntSymbol", { enumerable: true, get: function () { return types_1.isntSymbol; } });
 	
-} (es2018$5));
+} (es2018$6));
 
 var State;
 (function (State) {
@@ -16633,10 +16662,14 @@ const schema = {
 };
 class GameLoop {
     constructor(options) {
-        this.fsm = new es2018$e.FiniteStateMachine(schema, State.Stopped);
+        this.fsm = new es2018$f.FiniteStateMachine(schema, State.Stopped);
         this.deltaTimeAccumulator = 0;
         this.lastDeltaTime = 0;
-        this.loop = (timestamp) => {
+        this.loop = () => {
+            // requestAnimationFrame的实现存在陷阱, 它提供的timestamp参数有时会比`performance.now()`早.
+            // 因此主动调用`performance.now()`来获取时间戳.
+            // https://stackoverflow.com/questions/50895206/exact-time-of-display-requestanimationframe-usage-and-timeline
+            const timestamp = performance.now();
             const deltaTime = timestamp - this.lastTimestamp;
             this.lastDeltaTime = deltaTime;
             this.lastTimestamp = timestamp;
@@ -16645,16 +16678,15 @@ class GameLoop {
         };
         this.fixedDeltaTime = options.fixedDeltaTime;
         this.maximumDeltaTime = options.maximumDeltaTime;
-        es2018$5.assert(this.maximumDeltaTime >= this.fixedDeltaTime, 'maximumDeltaTime must be greater than or equal to fixedDeltaTime');
+        es2018$6.assert(this.maximumDeltaTime >= this.fixedDeltaTime, 'maximumDeltaTime must be greater than or equal to fixedDeltaTime');
         this.fixedUpdate = options.fixedUpdate;
         this.update = options.update;
         this.render = options.render;
     }
     start() {
         this.fsm.send('start');
-        const timestamp = performance.now();
-        this.lastTimestamp = timestamp;
-        this.loop(timestamp);
+        this.lastTimestamp = performance.now();
+        this.loop();
     }
     stop() {
         this.fsm.send('stop');