Fix bin/publish: copy docs.dist from project root

Fix bin/publish: use correct .env path for rspade_system
Fix bin/publish script: prevent grep exit code 1 from terminating script

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/spatie/ignition/node_modules/babel-plugin-transform-async-to-promises/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017-2019 Ryan Petrich <rpetrich@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

vendor/spatie/ignition/node_modules/babel-plugin-transform-async-to-promises/README.md

@@ -0,0 +1,80 @@
+babel-plugin-transform-async-to-promises
+========================================
+
+Babel plugin to transform `async` functions containing `await` expressions to the equivalent chain of `Promise` calls with use of minimal helper functions.
+
+[![Build Status](https://travis-ci.org/rpetrich/babel-plugin-transform-async-to-promises.svg?branch=master)](https://travis-ci.org/rpetrich/babel-plugin-transform-async-to-promises)
+
+### Input:
+
+```javascript
+async function fetchAsObjectURL(url) {
+    const response = await fetch(url);
+    const blob = await response.blob();
+    return URL.createObjectURL(blob);
+}
+```
+
+### Output:
+
+```javascript
+const fetchAsObjectURL = _async(function(url) {
+	return _await(fetch(url), function(response) {
+		return _await(response.blob(), URL.createObjectURL);
+	});
+});
+```
+
+### Output with `hoist` enabled:
+
+```javascript
+function _response$blob(response) {
+	return _await(response.blob(), URL.createObjectURL);
+}
+const fetchAsObjectURL = _async(function(url) {
+	return _await(fetch(url), _response$blob);
+});
+```
+
+### Output with `inlineHelpers` enabled:
+
+```javascript
+const fetchAsObjectURL = function(url) {
+	try {
+		return Promise.resolve(fetch(url)).then(function(response) {
+			return Promise.resolve(response.blob()).then(URL.createObjectURL);
+		});
+	} catch(e) {
+		return Promise.reject(e);
+	}
+}
+```
+
+## JavaScript Language Features
+
+### Full Support
+- `async`/`await`
+- `for`/`while`/`do` loops (including loops that would exhaust stack if dispatched recursively)
+- `switch` statements (including fallthrough and `default` cases)
+- conditional expressions
+- logical expressions
+- `try`/`catch`
+- `break`/`continue` statements (on both loops and labeled statements)
+- `throw` expressions
+- Function hoisting
+- Variable hoisting
+- Arrow functions
+- Methods
+- `arguments`
+- `this`
+- Proper member dereference order of operations
+- Standards-compliant event loop scheduling
+
+### Partial Support
+- `Function.length`: `async` functions will often return a length of 0 (when the `_async` wrapper is used)
+
+### No support
+- `eval`: impossible to support without deep hooks into the runtime
+- Async generator functions: not implemented or planned
+- `Function.name`: rewrite pass removes function name instrumentation
+- `new AsyncFunction(...)`: impossible to support without shipping babel and the plugin in the output

vendor/spatie/ignition/node_modules/babel-plugin-transform-async-to-promises/helpers.js

@@ -0,0 +1,741 @@
+// 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;
+})();