swc/tests/fixture/issue-1721/case1/output/index.js
강동윤 72c9f4373a
fix(es): Fix bugs (#2055)
swc_ecma_parser:
 - Fix panic from span assertion. (#2040)

swc_ecma_transforms_compat:
 - Fix handling of `await for`. (#1918)

swc_ecma_transforms_base:
 - Allow using decorator metadata even if `reflect-metadata` is not imported. (#1362)
2021-08-12 12:28:58 +00:00

234 lines
7.0 KiB
JavaScript

import regeneratorRuntime from "regenerator-runtime";
function AsyncGenerator(gen) {
var front, back;
function send(key, arg) {
return new Promise(function(resolve, reject) {
var request = {
key: key,
arg: arg,
resolve: resolve,
reject: reject,
next: null
};
if (back) {
back = back.next = request;
} else {
front = back = request;
resume(key, arg);
}
});
}
function resume(key, arg) {
try {
var result = gen[key](arg);
var value = result.value;
var wrappedAwait = value instanceof _AwaitValue;
Promise.resolve(wrappedAwait ? value.wrapped : value).then(function(arg) {
if (wrappedAwait) {
resume("next", arg);
return;
}
settle(result.done ? "return" : "normal", arg);
}, function(err) {
resume("throw", err);
});
} catch (err) {
settle("throw", err);
}
}
function settle(type, value) {
switch(type){
case "return":
front.resolve({
value: value,
done: true
});
break;
case "throw":
front.reject(value);
break;
default:
front.resolve({
value: value,
done: false
});
break;
}
front = front.next;
if (front) {
resume(front.key, front.arg);
} else {
back = null;
}
}
this._invoke = send;
if (typeof gen.return !== "function") {
this.return = undefined;
}
}
if (typeof Symbol === "function" && Symbol.asyncIterator) {
AsyncGenerator.prototype[Symbol.asyncIterator] = function() {
return this;
};
}
AsyncGenerator.prototype.next = function(arg) {
return this._invoke("next", arg);
};
AsyncGenerator.prototype.throw = function(arg) {
return this._invoke("throw", arg);
};
AsyncGenerator.prototype.return = function(arg) {
return this._invoke("return", arg);
};
function _asyncIterator(iterable) {
var method;
if (typeof Symbol === "function") {
if (Symbol.asyncIterator) {
method = iterable[Symbol.asyncIterator];
if (method != null) return method.call(iterable);
}
if (Symbol.iterator) {
method = iterable[Symbol.iterator];
if (method != null) return method.call(iterable);
}
}
throw new TypeError("Object is not async iterable");
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _AwaitValue(value) {
this.wrapped = value;
}
function _wrapAsyncGenerator(fn) {
return function() {
return new AsyncGenerator(fn.apply(this, arguments));
};
}
function _lol() {
_lol = _wrapAsyncGenerator(regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_ctx) {
while(1)switch(_ctx.prev = _ctx.next){
case 0:
_ctx.next = 2;
return 1;
case 2:
_ctx.next = 4;
return 2;
case 4:
case "end":
return _ctx.stop();
}
}, _callee);
}));
return _lol.apply(this, arguments);
}
function lol() {
return _lol.apply(this, arguments);
}
function _main() {
_main = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, x;
return regeneratorRuntime.wrap(function _callee$(_ctx) {
while(1)switch(_ctx.prev = _ctx.next){
case 0:
_iteratorAbruptCompletion = false, _didIteratorError = false;
_ctx.prev = 1;
_iterator = _asyncIterator(lol());
case 3:
_ctx.next = 5;
return _iterator.next();
case 5:
if (!(_iteratorAbruptCompletion = !(_step = _ctx.sent).done)) {
_ctx.next = 10;
break;
}
{
_value = _step.value;
x = _value;
console.log(x);
}
case 7:
_iteratorAbruptCompletion = false;
_ctx.next = 3;
break;
case 10:
_ctx.next = 16;
break;
case 12:
_ctx.prev = 12;
_ctx.t0 = _ctx["catch"](1);
_didIteratorError = true;
_iteratorError = _ctx.t0;
case 16:
_ctx.prev = 16;
_ctx.prev = 17;
if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
_ctx.next = 21;
break;
}
_ctx.next = 21;
return _iteratorError.return();
case 21:
_ctx.prev = 21;
if (!_didIteratorError) {
_ctx.next = 24;
break;
}
throw _iteratorError;
case 24:
return _ctx.finish(21);
case 25:
return _ctx.finish(16);
case 26:
case "end":
return _ctx.stop();
}
}, _callee, null, [
[
17,
,
21,
25
],
[
1,
12,
16,
26
]
]);
}));
return _main.apply(this, arguments);
}
function main() {
return _main.apply(this, arguments);
}
main();