helpers.js

// A type of promise-like that resolves synchronously and supports only one observer
export const _Pact = /*#__PURE__*/(function() {
	function _Pact() {}
	_Pact.prototype.then = function(onFulfilled, onRejected) {
		const result = new _Pact();
		const state = this.s;
		if (state) {
			const callback = state & 1 ? onFulfilled : onRejected;
			if (callback) {
				try {
					_settle(result, 1, callback(this.v));
				} catch (e) {
					_settle(result, 2, e);
				}
				return result;
			} else {
				return this;
			}
		}
		this.o = function(_this) {
			try {
				const value = _this.v;
				if (_this.s & 1) {
					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
				} else if (onRejected) {
					_settle(result, 1, onRejected(value));
				} else {
					_settle(result, 2, value);
				}
			} catch (e) {
				_settle(result, 2, e);
			}
		};
		return result;
	}
	return _Pact;
})();

// Settles a pact synchronously
export function _settle(pact, state, value) {
	if (!pact.s) {
		if (value instanceof _Pact) {
			if (value.s) {
				if (state & 1) {
					state = value.s;
				}
				value = value.v;
			} else {
				value.o = _settle.bind(null, pact, state);
				return;
			}
		}
		if (value && value.then) {
			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
			return;
		}
		pact.s = state;
		pact.v = value;
		const observer = pact.o;
		if (observer) {
			observer(pact);
		}
	}
}

export function _isSettledPact(thenable) {
	return thenable instanceof _Pact && thenable.s & 1;
}

// Converts argument to a function that always returns a Promise
export function _async(f) {
	return function() {
		for (var args = [], i = 0; i < arguments.length; i++) {
			args[i] = arguments[i];
		}
		try {
			return Promise.resolve(f.apply(this, args));
		} catch(e) {
			return Promise.reject(e);
		}
	}
}

// Awaits on a value that may or may not be a Promise (equivalent to the await keyword in ES2015, with continuations passed explicitly)
export function _await(value, then, direct) {
	if (direct) {
		return then ? then(value) : value;
	}
	if (!value || !value.then) {
		value = Promise.resolve(value);
	}
	return then ? value.then(then) : value;
}

// Awaits on a value that may or may not be a Promise, then ignores it
export function _awaitIgnored(value, direct) {
	if (!direct) {
		return value && value.then ? value.then(_empty) : Promise.resolve();
	}
}

// Proceeds after a value has resolved, or proceeds immediately if the value is not thenable
export function _continue(value, then) {
	return value && value.then ? value.then(then) : then(value);
}

// Proceeds after a value has resolved, or proceeds immediately if the value is not thenable
export function _continueIgnored(value) {
	if (value && value.then) {
		return value.then(_empty);
	}
}

// Asynchronously iterate through an object that has a length property, passing the index as the first argument to the callback (even as the length property changes)
export function _forTo(array, body, check) {
	var i = -1, pact, reject;
	function _cycle(result) {
		try {
			while (++i < array.length && (!check || !check())) {
				result = body(i);
				if (result && result.then) {
					if (_isSettledPact(result)) {
						result = result.v;
					} else {
						result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
						return;
					}
				}
			}
			if (pact) {
				_settle(pact, 1, result);
			} else {
				pact = result;
			}
		} catch (e) {
			_settle(pact || (pact = new _Pact()), 2, e);
		}
	}
	_cycle();
	return pact;
}

// Asynchronously iterate through an object's properties (including properties inherited from the prototype)
// Uses a snapshot of the object's properties
export function _forIn(target, body, check) {
	var keys = [];
	for (var key in target) {
		keys.push(key);
	}
	return _forTo(keys, function(i) { return body(keys[i]); }, check);
}

// Asynchronously iterate through an object's own properties (excluding properties inherited from the prototype)
// Uses a snapshot of the object's properties
export function _forOwn(target, body, check) {
	var keys = [];
	for (var key in target) {
		if (Object.prototype.hasOwnProperty.call(target, key)) {
			keys.push(key);
		}
	}
	return _forTo(keys, function(i) { return body(keys[i]); }, check);
}

export const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";

// Asynchronously iterate through an object's values
// Uses for...of if the runtime supports it, otherwise iterates until length on a copy
export function _forOf(target, body, check) {
	if (typeof target[_iteratorSymbol] === "function") {
		var iterator = target[_iteratorSymbol](), step, pact, reject;
		function _cycle(result) {
			try {
				while (!(step = iterator.next()).done && (!check || !check())) {
					result = body(step.value);
					if (result && result.then) {
						if (_isSettledPact(result)) {
							result = result.v;
						} else {
							result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
							return;
						}
					}
				}
				if (pact) {
					_settle(pact, 1, result);
				} else {
					pact = result;
				}
			} catch (e) {
				_settle(pact || (pact = new _Pact()), 2, e);
			}
		}
		_cycle();
		if (iterator.return) {
			var _fixup = function(value) {
				try {
					if (!step.done) {
						iterator.return();
					}
				} catch(e) {
				}
				return value;
			}
			if (pact && pact.then) {
				return pact.then(_fixup, function(e) {
					throw _fixup(e);
				});
			}
			_fixup();
		}
		return pact;
	}
	// No support for Symbol.iterator
	if (!("length" in target)) {
		throw new TypeError("Object is not iterable");
	}
	// Handle live collections properly
	var values = [];
	for (var i = 0; i < target.length; i++) {
		values.push(target[i]);
	}
	return _forTo(values, function(i) { return body(values[i]); }, check);
}

export const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";

// Asynchronously iterate on a value using it's async iterator if present, or its synchronous iterator if missing
export function _forAwaitOf(target, body, check) {
	if (typeof target[_asyncIteratorSymbol] === "function") {
		var pact = new _Pact();
		var iterator = target[_asyncIteratorSymbol]();
		iterator.next().then(_resumeAfterNext).then(void 0, _reject);
		return pact;
		function _resumeAfterBody(result) {
			if (check && check()) {
				return _settle(pact, 1, iterator.return ? iterator.return().then(function() { return result; }) : result);
			}
			iterator.next().then(_resumeAfterNext).then(void 0, _reject);
		}
		function _resumeAfterNext(step) {
			if (step.done) {
				_settle(pact, 1);
			} else {
				Promise.resolve(body(step.value)).then(_resumeAfterBody).then(void 0, _reject);
			}
		}
		function _reject(error) {
			_settle(pact, 2, iterator.return ? iterator.return().then(function() { return error; }) : error);
		}
	}
	return Promise.resolve(_forOf(target, function(value) { return Promise.resolve(value).then(body); }, check));
}

// Asynchronously implement a generic for loop
export function _for(test, update, body) {
	var stage;
	for (;;) {
		var shouldContinue = test();
		if (_isSettledPact(shouldContinue)) {
			shouldContinue = shouldContinue.v;
		}
		if (!shouldContinue) {
			return result;
		}
		if (shouldContinue.then) {
			stage = 0;
			break;
		}
		var result = body();
		if (result && result.then) {
			if (_isSettledPact(result)) {
				result = result.s;
			} else {
				stage = 1;
				break;
			}
		}
		if (update) {
			var updateValue = update();
			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
				stage = 2;
				break;
			}
		}
	}
	var pact = new _Pact();
	var reject = _settle.bind(null, pact, 2);
	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
	return pact;
	function _resumeAfterBody(value) {
		result = value;
		do {
			if (update) {
				updateValue = update();
				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
					return;
				}
			}
			shouldContinue = test();
			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
				_settle(pact, 1, result);
				return;
			}
			if (shouldContinue.then) {
				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
				return;
			}
			result = body();
			if (_isSettledPact(result)) {
				result = result.v;
			}
		} while (!result || !result.then);
		result.then(_resumeAfterBody).then(void 0, reject);
	}
	function _resumeAfterTest(shouldContinue) {
		if (shouldContinue) {
			result = body();
			if (result && result.then) {
				result.then(_resumeAfterBody).then(void 0, reject);
			} else {
				_resumeAfterBody(result);
			}
		} else {
			_settle(pact, 1, result);
		}
	}
	function _resumeAfterUpdate() {
		if (shouldContinue = test()) {
			if (shouldContinue.then) {
				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
			} else {
				_resumeAfterTest(shouldContinue);
			}
		} else {
			_settle(pact, 1, result);
		}
	}
}

// Asynchronously implement a do ... while loop
export function _do(body, test) {
	var awaitBody;
	do {
		var result = body();
		if (result && result.then) {
			if (_isSettledPact(result)) {
				result = result.v;
			} else {
				awaitBody = true;
				break;
			}
		}
		var shouldContinue = test();
		if (_isSettledPact(shouldContinue)) {
			shouldContinue = shouldContinue.v;
		}
		if (!shouldContinue) {
			return result;
		}
	} while (!shouldContinue.then);
	const pact = new _Pact();
	const reject = _settle.bind(null, pact, 2);
	(awaitBody ? result.then(_resumeAfterBody) : shouldContinue.then(_resumeAfterTest)).then(void 0, reject);
	return pact;
	function _resumeAfterBody(value) {
		result = value;
		for (;;) {
			shouldContinue = test();
			if (_isSettledPact(shouldContinue)) {
				shouldContinue = shouldContinue.v;
			}
			if (!shouldContinue) {
				break;
			}
			if (shouldContinue.then) {
				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
				return;
			}
			result = body();
			if (result && result.then) {
				if (_isSettledPact(result)) {
					result = result.v;
				} else {
					result.then(_resumeAfterBody).then(void 0, reject);
					return;
				}
			}
		}
		_settle(pact, 1, result);
	}
	function _resumeAfterTest(shouldContinue) {
		if (shouldContinue) {
			do {
				result = body();
				if (result && result.then) {
					if (_isSettledPact(result)) {
						result = result.v;
					} else {
						result.then(_resumeAfterBody).then(void 0, reject);
						return;
					}
				}
				shouldContinue = test();
				if (_isSettledPact(shouldContinue)) {
					shouldContinue = shouldContinue.v;
				}
				if (!shouldContinue) {
					_settle(pact, 1, result);
					return;
				}
			} while (!shouldContinue.then);
			shouldContinue.then(_resumeAfterTest).then(void 0, reject);
		} else {
			_settle(pact, 1, result);
		}
	}
}

// Asynchronously implement a switch statement
export function _switch(discriminant, cases) {
	var dispatchIndex = -1;
	var awaitBody;
	outer: {
		for (var i = 0; i < cases.length; i++) {
			var test = cases[i][0];
			if (test) {
				var testValue = test();
				if (testValue && testValue.then) {
					break outer;
				}
				if (testValue === discriminant) {
					dispatchIndex = i;
					break;
				}
			} else {
				// Found the default case, set it as the pending dispatch case
				dispatchIndex = i;
			}
		}
		if (dispatchIndex !== -1) {
			do {
				var body = cases[dispatchIndex][1];
				while (!body) {
					dispatchIndex++;
					body = cases[dispatchIndex][1];
				}
				var result = body();
				if (result && result.then) {
					awaitBody = true;
					break outer;
				}
				var fallthroughCheck = cases[dispatchIndex][2];
				dispatchIndex++;
			} while (fallthroughCheck && !fallthroughCheck());
			return result;
		}
	}
	const pact = new _Pact();
	const reject = _settle.bind(null, pact, 2);
	(awaitBody ? result.then(_resumeAfterBody) : testValue.then(_resumeAfterTest)).then(void 0, reject);
	return pact;
	function _resumeAfterTest(value) {
		for (;;) {
			if (value === discriminant) {
				dispatchIndex = i;
				break;
			}
			if (++i === cases.length) {
				if (dispatchIndex !== -1) {
					break;
				} else {
					_settle(pact, 1, result);
					return;
				}
			}
			test = cases[i][0];
			if (test) {
				value = test();
				if (value && value.then) {
					value.then(_resumeAfterTest).then(void 0, reject);
					return;
				}
			} else {
				dispatchIndex = i;
			}
		}
		do {
			var body = cases[dispatchIndex][1];
			while (!body) {
				dispatchIndex++;
				body = cases[dispatchIndex][1];
			}
			var result = body();
			if (result && result.then) {
				result.then(_resumeAfterBody).then(void 0, reject);
				return;
			}
			var fallthroughCheck = cases[dispatchIndex][2];
			dispatchIndex++;
		} while (fallthroughCheck && !fallthroughCheck());
		_settle(pact, 1, result);
	}
	function _resumeAfterBody(result) {
		for (;;) {
			var fallthroughCheck = cases[dispatchIndex][2];
			if (!fallthroughCheck || fallthroughCheck()) {
				break;
			}
			dispatchIndex++;
			var body = cases[dispatchIndex][1];
			while (!body) {
				dispatchIndex++;
				body = cases[dispatchIndex][1];
			}
			result = body();
			if (result && result.then) {
				result.then(_resumeAfterBody).then(void 0, reject);
				return;
			}
		}
		_settle(pact, 1, result);
	}
}

// Asynchronously call a function and pass the result to explicitly passed continuations
export function _call(body, then, direct) {
	if (direct) {
		return then ? then(body()) : body();
	}
	try {
		var result = Promise.resolve(body());
		return then ? result.then(then) : result;
	} catch (e) {
		return Promise.reject(e);
	}
}

// Asynchronously call a function and swallow the result
export function _callIgnored(body, direct) {
	return _call(body, _empty, direct);
}

// Asynchronously call a function and pass the result to explicitly passed continuations
export function _invoke(body, then) {
	var result = body();
	if (result && result.then) {
		return result.then(then);
	}
	return then(result);
}

// Asynchronously call a function and swallow the result
export function _invokeIgnored(body) {
	var result = body();
	if (result && result.then) {
		return result.then(_empty);
	}
}

// Asynchronously call a function and send errors to recovery continuation
export function _catch(body, recover) {
	try {
		var result = body();
	} catch(e) {
		return recover(e);
	}
	if (result && result.then) {
		return result.then(void 0, recover);
	}
	return result;
}

// Asynchronously await a promise and pass the result to a finally continuation
export function _finallyRethrows(body, finalizer) {
	try {
		var result = body();
	} catch (e) {
		return finalizer(true, e);
	}
	if (result && result.then) {
		return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
	}
	return finalizer(false, result);
}

// Asynchronously await a promise and invoke a finally continuation that always overrides the result
export function _finally(body, finalizer) {
	try {
		var result = body();
	} catch (e) {
		return finalizer();
	}
	if (result && result.then) {
		return result.then(finalizer, finalizer);
	}
	return finalizer();
}

// Rethrow or return a value from a finally continuation
export function _rethrow(thrown, value) {
	if (thrown)
		throw value;
	return value;
}

// Empty function to implement break and other control flow that ignores asynchronous results
export function _empty() {
}

// Sentinel value for early returns in generators 
export const _earlyReturn = /*#__PURE__*/ {};

// Asynchronously call a function and send errors to recovery continuation, skipping early returns
export function _catchInGenerator(body, recover) {
	return _catch(body, function(e) {
		if (e === _earlyReturn) {
			throw e;
		}
		return recover(e);
	});
}

// Asynchronous generator class; accepts the entrypoint of the generator, to which it passes itself when the generator should start
export const _AsyncGenerator = /*#__PURE__*/(function() {
	function _AsyncGenerator(entry) {
		this._entry = entry;
		this._pact = null;
		this._resolve = null;
		this._return = null;
		this._promise = null;
	}

	function _wrapReturnedValue(value) {
		return { value: value, done: true };
	}
	function _wrapYieldedValue(value) {
		return { value: value, done: false };
	}

	_AsyncGenerator.prototype._yield = function(value) {
		// Yield the value to the pending next call
		this._resolve(value && value.then ? value.then(_wrapYieldedValue) : _wrapYieldedValue(value));
		// Return a pact for an upcoming next/return/throw call
		return this._pact = new _Pact();
	};
	_AsyncGenerator.prototype.next = function(value) {
		// Advance the generator, starting it if it has yet to be started
		const _this = this;
		return _this._promise = new Promise(function (resolve) {
			const _pact = _this._pact;
			if (_pact === null) {
				const _entry = _this._entry;
				if (_entry === null) {
					// Generator is started, but not awaiting a yield expression
					// Abandon the next call!
					return resolve(_this._promise);
				}
				// Start the generator
				_this._entry = null;
				_this._resolve = resolve;
				function returnValue(value) {
					_this._resolve(value && value.then ? value.then(_wrapReturnedValue) : _wrapReturnedValue(value));
					_this._pact = null;
					_this._resolve = null;
				}
				var result = _entry(_this);
				if (result && result.then) {
					result.then(returnValue, function(error) {
						if (error === _earlyReturn) {
							returnValue(_this._return);
						} else {
							const pact = new _Pact();
							_this._resolve(pact);
							_this._pact = null;
							_this._resolve = null;
							_resolve(pact, 2, error);
						}
					});
				} else {
					returnValue(result);
				}
			} else {
				// Generator is started and a yield expression is pending, settle it
				_this._pact = null;
				_this._resolve = resolve;
				_settle(_pact, 1, value);
			}
		});
	};
	_AsyncGenerator.prototype.return = function(value) {
		// Early return from the generator if started, otherwise abandons the generator
		const _this = this;
		return _this._promise = new Promise(function (resolve) {
			const _pact = _this._pact;
			if (_pact === null) {
				if (_this._entry === null) {
					// Generator is started, but not awaiting a yield expression
					// Abandon the return call!
					return resolve(_this._promise);
				}
				// Generator is not started, abandon it and return the specified value
				_this._entry = null;
				return resolve(value && value.then ? value.then(_wrapReturnedValue) : _wrapReturnedValue(value));
			}
			// Settle the yield expression with a rejected "early return" value
			_this._return = value;
			_this._resolve = resolve;
			_this._pact = null;
			_settle(_pact, 2, _earlyReturn);
		});
	};
	_AsyncGenerator.prototype.throw = function(error) {
		// Inject an exception into the pending yield expression
		const _this = this;
		return _this._promise = new Promise(function (resolve, reject) {
			const _pact = _this._pact;
			if (_pact === null) {
				if (_this._entry === null) {
					// Generator is started, but not awaiting a yield expression
					// Abandon the throw call!
					return resolve(_this._promise);
				}
				// Generator is not started, abandon it and return a rejected Promise containing the error
				_this._entry = null;
				return reject(error);
			}
			// Settle the yield expression with the value as a rejection
			_this._resolve = resolve;
			_this._pact = null;
			_settle(_pact, 2, error);
		});
	};

	_AsyncGenerator.prototype[_asyncIteratorSymbol] = function() {
		return this;
	};
	
	return _AsyncGenerator;
})();