mirror of
https://github.com/hanzoai/esbuild.git
synced 2026-10-30 14:46:14 +00:00
4914 lines
128 KiB
Plaintext
4914 lines
128 KiB
Plaintext
TestClassSuperThisIssue242NoBundle
|
|
---------- /out.js ----------
|
|
var _e;
|
|
export class A {
|
|
}
|
|
export class B extends A {
|
|
constructor(c) {
|
|
var _a;
|
|
super();
|
|
__privateAdd(this, _e);
|
|
__privateSet(this, _e, (_a = c.d) != null ? _a : "test");
|
|
}
|
|
f() {
|
|
return __privateGet(this, _e);
|
|
}
|
|
}
|
|
_e = new WeakMap();
|
|
|
|
================================================================================
|
|
TestForAwaitWithOptionalCatchIssue4378
|
|
---------- /out.js ----------
|
|
async function test(b) {
|
|
try {
|
|
for (var iter = __forAwait(b), more, temp, error; more = !(temp = await iter.next()).done; more = !1) {
|
|
const a = temp.value;
|
|
a();
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestJavaScriptAutoAccessorES2021
|
|
---------- /out/js-define.js ----------
|
|
var _a, _b, _one, __two, _Foo_instances, two_get, two_set, _a2, _four, __five, _Foo_static, five_get, five_set, _b2;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _one, 1);
|
|
__privateAdd(this, __two, 2);
|
|
__privateAdd(this, _a2, 3);
|
|
}
|
|
get one() {
|
|
return __privateGet(this, _one);
|
|
}
|
|
set one(_) {
|
|
__privateSet(this, _one, _);
|
|
}
|
|
get [_b = three()]() {
|
|
return __privateGet(this, _a2);
|
|
}
|
|
set [_b](_) {
|
|
__privateSet(this, _a2, _);
|
|
}
|
|
static get four() {
|
|
return __privateGet(this, _four);
|
|
}
|
|
static set four(_) {
|
|
__privateSet(this, _four, _);
|
|
}
|
|
static get [_a = six()]() {
|
|
return __privateGet(this, _b2);
|
|
}
|
|
static set [_a](_) {
|
|
__privateSet(this, _b2, _);
|
|
}
|
|
}
|
|
_one = new WeakMap();
|
|
__two = new WeakMap();
|
|
_Foo_instances = new WeakSet();
|
|
two_get = function() {
|
|
return __privateGet(this, __two);
|
|
};
|
|
two_set = function(_) {
|
|
__privateSet(this, __two, _);
|
|
};
|
|
_a2 = new WeakMap();
|
|
_four = new WeakMap();
|
|
__five = new WeakMap();
|
|
_Foo_static = new WeakSet();
|
|
five_get = function() {
|
|
return __privateGet(this, __five);
|
|
};
|
|
five_set = function(_) {
|
|
__privateSet(this, __five, _);
|
|
};
|
|
_b2 = new WeakMap();
|
|
__privateAdd(Foo, _Foo_static);
|
|
__privateAdd(Foo, _four, 4);
|
|
__privateAdd(Foo, __five, 5);
|
|
__privateAdd(Foo, _b2, 6);
|
|
|
|
---------- /out/ts-define/ts-define.js ----------
|
|
var _a, _b, _one, __two, _Foo_instances, two_get, two_set, _a2, _four, __five, _Foo_static, five_get, five_set, _b2, _a3, __a, _Private_instances, a_get, a_set, _a4, __a2, _StaticPrivate_static, a_get2, a_set2;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _one, 1);
|
|
__privateAdd(this, __two, 2);
|
|
__privateAdd(this, _a2, 3);
|
|
}
|
|
get one() {
|
|
return __privateGet(this, _one);
|
|
}
|
|
set one(_) {
|
|
__privateSet(this, _one, _);
|
|
}
|
|
get [_b = three()]() {
|
|
return __privateGet(this, _a2);
|
|
}
|
|
set [_b](_) {
|
|
__privateSet(this, _a2, _);
|
|
}
|
|
static get four() {
|
|
return __privateGet(this, _four);
|
|
}
|
|
static set four(_) {
|
|
__privateSet(this, _four, _);
|
|
}
|
|
static get [_a = six()]() {
|
|
return __privateGet(this, _b2);
|
|
}
|
|
static set [_a](_) {
|
|
__privateSet(this, _b2, _);
|
|
}
|
|
}
|
|
_one = new WeakMap();
|
|
__two = new WeakMap();
|
|
_Foo_instances = new WeakSet();
|
|
two_get = function() {
|
|
return __privateGet(this, __two);
|
|
};
|
|
two_set = function(_) {
|
|
__privateSet(this, __two, _);
|
|
};
|
|
_a2 = new WeakMap();
|
|
_four = new WeakMap();
|
|
__five = new WeakMap();
|
|
_Foo_static = new WeakSet();
|
|
five_get = function() {
|
|
return __privateGet(this, __five);
|
|
};
|
|
five_set = function(_) {
|
|
__privateSet(this, __five, _);
|
|
};
|
|
_b2 = new WeakMap();
|
|
__privateAdd(Foo, _Foo_static);
|
|
__privateAdd(Foo, _four, 4);
|
|
__privateAdd(Foo, __five, 5);
|
|
__privateAdd(Foo, _b2, 6);
|
|
class Normal {
|
|
constructor() {
|
|
__privateAdd(this, _a3, b);
|
|
__publicField(this, "c", d);
|
|
}
|
|
get a() {
|
|
return __privateGet(this, _a3);
|
|
}
|
|
set a(_) {
|
|
__privateSet(this, _a3, _);
|
|
}
|
|
}
|
|
_a3 = new WeakMap();
|
|
class Private {
|
|
constructor() {
|
|
__privateAdd(this, _Private_instances);
|
|
__privateAdd(this, __a, b);
|
|
__publicField(this, "c", d);
|
|
}
|
|
}
|
|
__a = new WeakMap();
|
|
_Private_instances = new WeakSet();
|
|
a_get = function() {
|
|
return __privateGet(this, __a);
|
|
};
|
|
a_set = function(_) {
|
|
__privateSet(this, __a, _);
|
|
};
|
|
class StaticNormal {
|
|
static get a() {
|
|
return __privateGet(this, _a4);
|
|
}
|
|
static set a(_) {
|
|
__privateSet(this, _a4, _);
|
|
}
|
|
}
|
|
_a4 = new WeakMap();
|
|
__privateAdd(StaticNormal, _a4, b);
|
|
__publicField(StaticNormal, "c", d);
|
|
class StaticPrivate {
|
|
}
|
|
__a2 = new WeakMap();
|
|
_StaticPrivate_static = new WeakSet();
|
|
a_get2 = function() {
|
|
return __privateGet(this, __a2);
|
|
};
|
|
a_set2 = function(_) {
|
|
__privateSet(this, __a2, _);
|
|
};
|
|
__privateAdd(StaticPrivate, _StaticPrivate_static);
|
|
__privateAdd(StaticPrivate, __a2, b);
|
|
__publicField(StaticPrivate, "c", d);
|
|
|
|
---------- /out/ts-assign/ts-assign.js ----------
|
|
var _a, _b, _one, __two, _Foo_instances, two_get, two_set, _a2, _four, __five, _Foo_static, five_get, five_set, _b2, _a3, __a, _Private_instances, a_get, a_set, _a4, __a2, _StaticPrivate_static, a_get2, a_set2;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _one, 1);
|
|
__privateAdd(this, __two, 2);
|
|
__privateAdd(this, _a2, 3);
|
|
}
|
|
get one() {
|
|
return __privateGet(this, _one);
|
|
}
|
|
set one(_) {
|
|
__privateSet(this, _one, _);
|
|
}
|
|
get [_b = three()]() {
|
|
return __privateGet(this, _a2);
|
|
}
|
|
set [_b](_) {
|
|
__privateSet(this, _a2, _);
|
|
}
|
|
static get four() {
|
|
return __privateGet(this, _four);
|
|
}
|
|
static set four(_) {
|
|
__privateSet(this, _four, _);
|
|
}
|
|
static get [_a = six()]() {
|
|
return __privateGet(this, _b2);
|
|
}
|
|
static set [_a](_) {
|
|
__privateSet(this, _b2, _);
|
|
}
|
|
}
|
|
_one = new WeakMap();
|
|
__two = new WeakMap();
|
|
_Foo_instances = new WeakSet();
|
|
two_get = function() {
|
|
return __privateGet(this, __two);
|
|
};
|
|
two_set = function(_) {
|
|
__privateSet(this, __two, _);
|
|
};
|
|
_a2 = new WeakMap();
|
|
_four = new WeakMap();
|
|
__five = new WeakMap();
|
|
_Foo_static = new WeakSet();
|
|
five_get = function() {
|
|
return __privateGet(this, __five);
|
|
};
|
|
five_set = function(_) {
|
|
__privateSet(this, __five, _);
|
|
};
|
|
_b2 = new WeakMap();
|
|
__privateAdd(Foo, _Foo_static);
|
|
__privateAdd(Foo, _four, 4);
|
|
__privateAdd(Foo, __five, 5);
|
|
__privateAdd(Foo, _b2, 6);
|
|
class Normal {
|
|
constructor() {
|
|
__privateAdd(this, _a3, b);
|
|
this.c = d;
|
|
}
|
|
get a() {
|
|
return __privateGet(this, _a3);
|
|
}
|
|
set a(_) {
|
|
__privateSet(this, _a3, _);
|
|
}
|
|
}
|
|
_a3 = new WeakMap();
|
|
class Private {
|
|
constructor() {
|
|
__privateAdd(this, _Private_instances);
|
|
__privateAdd(this, __a, b);
|
|
this.c = d;
|
|
}
|
|
}
|
|
__a = new WeakMap();
|
|
_Private_instances = new WeakSet();
|
|
a_get = function() {
|
|
return __privateGet(this, __a);
|
|
};
|
|
a_set = function(_) {
|
|
__privateSet(this, __a, _);
|
|
};
|
|
class StaticNormal {
|
|
static get a() {
|
|
return __privateGet(this, _a4);
|
|
}
|
|
static set a(_) {
|
|
__privateSet(this, _a4, _);
|
|
}
|
|
}
|
|
_a4 = new WeakMap();
|
|
__privateAdd(StaticNormal, _a4, b);
|
|
StaticNormal.c = d;
|
|
class StaticPrivate {
|
|
}
|
|
__a2 = new WeakMap();
|
|
_StaticPrivate_static = new WeakSet();
|
|
a_get2 = function() {
|
|
return __privateGet(this, __a2);
|
|
};
|
|
a_set2 = function(_) {
|
|
__privateSet(this, __a2, _);
|
|
};
|
|
__privateAdd(StaticPrivate, _StaticPrivate_static);
|
|
__privateAdd(StaticPrivate, __a2, b);
|
|
StaticPrivate.c = d;
|
|
|
|
================================================================================
|
|
TestJavaScriptAutoAccessorES2022
|
|
---------- /out/js-define.js ----------
|
|
var _a, _b;
|
|
class Foo {
|
|
#one = 1;
|
|
get one() {
|
|
return this.#one;
|
|
}
|
|
set one(_) {
|
|
this.#one = _;
|
|
}
|
|
#_two = 2;
|
|
get #two() {
|
|
return this.#_two;
|
|
}
|
|
set #two(_) {
|
|
this.#_two = _;
|
|
}
|
|
#a = 3;
|
|
get [_b = three()]() {
|
|
return this.#a;
|
|
}
|
|
set [_b](_) {
|
|
this.#a = _;
|
|
}
|
|
static #four = 4;
|
|
static get four() {
|
|
return this.#four;
|
|
}
|
|
static set four(_) {
|
|
this.#four = _;
|
|
}
|
|
static #_five = 5;
|
|
static get #five() {
|
|
return this.#_five;
|
|
}
|
|
static set #five(_) {
|
|
this.#_five = _;
|
|
}
|
|
static #b = 6;
|
|
static get [_a = six()]() {
|
|
return this.#b;
|
|
}
|
|
static set [_a](_) {
|
|
this.#b = _;
|
|
}
|
|
}
|
|
|
|
---------- /out/ts-define/ts-define.js ----------
|
|
var _a, _b;
|
|
class Foo {
|
|
#one = 1;
|
|
get one() {
|
|
return this.#one;
|
|
}
|
|
set one(_) {
|
|
this.#one = _;
|
|
}
|
|
#_two = 2;
|
|
get #two() {
|
|
return this.#_two;
|
|
}
|
|
set #two(_) {
|
|
this.#_two = _;
|
|
}
|
|
#a = 3;
|
|
get [_b = three()]() {
|
|
return this.#a;
|
|
}
|
|
set [_b](_) {
|
|
this.#a = _;
|
|
}
|
|
static #four = 4;
|
|
static get four() {
|
|
return this.#four;
|
|
}
|
|
static set four(_) {
|
|
this.#four = _;
|
|
}
|
|
static #_five = 5;
|
|
static get #five() {
|
|
return this.#_five;
|
|
}
|
|
static set #five(_) {
|
|
this.#_five = _;
|
|
}
|
|
static #b = 6;
|
|
static get [_a = six()]() {
|
|
return this.#b;
|
|
}
|
|
static set [_a](_) {
|
|
this.#b = _;
|
|
}
|
|
}
|
|
class Normal {
|
|
#a = b;
|
|
get a() {
|
|
return this.#a;
|
|
}
|
|
set a(_) {
|
|
this.#a = _;
|
|
}
|
|
c = d;
|
|
}
|
|
class Private {
|
|
#_a = b;
|
|
get #a() {
|
|
return this.#_a;
|
|
}
|
|
set #a(_) {
|
|
this.#_a = _;
|
|
}
|
|
c = d;
|
|
}
|
|
class StaticNormal {
|
|
static #a = b;
|
|
static get a() {
|
|
return this.#a;
|
|
}
|
|
static set a(_) {
|
|
this.#a = _;
|
|
}
|
|
static c = d;
|
|
}
|
|
class StaticPrivate {
|
|
static #_a = b;
|
|
static get #a() {
|
|
return this.#_a;
|
|
}
|
|
static set #a(_) {
|
|
this.#_a = _;
|
|
}
|
|
static c = d;
|
|
}
|
|
|
|
---------- /out/ts-assign/ts-assign.js ----------
|
|
var _a, _b, _a2, __a;
|
|
class Foo {
|
|
#one = 1;
|
|
get one() {
|
|
return this.#one;
|
|
}
|
|
set one(_) {
|
|
this.#one = _;
|
|
}
|
|
#_two = 2;
|
|
get #two() {
|
|
return this.#_two;
|
|
}
|
|
set #two(_) {
|
|
this.#_two = _;
|
|
}
|
|
#a = 3;
|
|
get [_b = three()]() {
|
|
return this.#a;
|
|
}
|
|
set [_b](_) {
|
|
this.#a = _;
|
|
}
|
|
static #four = 4;
|
|
static get four() {
|
|
return this.#four;
|
|
}
|
|
static set four(_) {
|
|
this.#four = _;
|
|
}
|
|
static #_five = 5;
|
|
static get #five() {
|
|
return this.#_five;
|
|
}
|
|
static set #five(_) {
|
|
this.#_five = _;
|
|
}
|
|
static #b = 6;
|
|
static get [_a = six()]() {
|
|
return this.#b;
|
|
}
|
|
static set [_a](_) {
|
|
this.#b = _;
|
|
}
|
|
}
|
|
class Normal {
|
|
constructor() {
|
|
__privateAdd(this, _a2, b);
|
|
this.c = d;
|
|
}
|
|
get a() {
|
|
return __privateGet(this, _a2);
|
|
}
|
|
set a(_) {
|
|
__privateSet(this, _a2, _);
|
|
}
|
|
}
|
|
_a2 = new WeakMap();
|
|
class Private {
|
|
constructor() {
|
|
__privateAdd(this, __a, b);
|
|
this.c = d;
|
|
}
|
|
get #a() {
|
|
return __privateGet(this, __a);
|
|
}
|
|
set #a(_) {
|
|
__privateSet(this, __a, _);
|
|
}
|
|
}
|
|
__a = new WeakMap();
|
|
class StaticNormal {
|
|
static #a = b;
|
|
static get a() {
|
|
return this.#a;
|
|
}
|
|
static set a(_) {
|
|
this.#a = _;
|
|
}
|
|
static {
|
|
this.c = d;
|
|
}
|
|
}
|
|
class StaticPrivate {
|
|
static #_a = b;
|
|
static get #a() {
|
|
return this.#_a;
|
|
}
|
|
static set #a(_) {
|
|
this.#_a = _;
|
|
}
|
|
static {
|
|
this.c = d;
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestJavaScriptAutoAccessorESNext
|
|
---------- /out/js-define.js ----------
|
|
class Foo {
|
|
accessor one = 1;
|
|
accessor #two = 2;
|
|
accessor [three()] = 3;
|
|
static accessor four = 4;
|
|
static accessor #five = 5;
|
|
static accessor [six()] = 6;
|
|
}
|
|
|
|
---------- /out/ts-define/ts-define.js ----------
|
|
class Foo {
|
|
accessor one = 1;
|
|
accessor #two = 2;
|
|
accessor [three()] = 3;
|
|
static accessor four = 4;
|
|
static accessor #five = 5;
|
|
static accessor [six()] = 6;
|
|
}
|
|
class Normal {
|
|
accessor a = b;
|
|
c = d;
|
|
}
|
|
class Private {
|
|
accessor #a = b;
|
|
c = d;
|
|
}
|
|
class StaticNormal {
|
|
static accessor a = b;
|
|
static c = d;
|
|
}
|
|
class StaticPrivate {
|
|
static accessor #a = b;
|
|
static c = d;
|
|
}
|
|
|
|
---------- /out/ts-assign/ts-assign.js ----------
|
|
var _a, __a;
|
|
class Foo {
|
|
accessor one = 1;
|
|
accessor #two = 2;
|
|
accessor [three()] = 3;
|
|
static accessor four = 4;
|
|
static accessor #five = 5;
|
|
static accessor [six()] = 6;
|
|
}
|
|
class Normal {
|
|
constructor() {
|
|
__privateAdd(this, _a, b);
|
|
this.c = d;
|
|
}
|
|
get a() {
|
|
return __privateGet(this, _a);
|
|
}
|
|
set a(_) {
|
|
__privateSet(this, _a, _);
|
|
}
|
|
}
|
|
_a = new WeakMap();
|
|
class Private {
|
|
constructor() {
|
|
__privateAdd(this, __a, b);
|
|
this.c = d;
|
|
}
|
|
get #a() {
|
|
return __privateGet(this, __a);
|
|
}
|
|
set #a(_) {
|
|
__privateSet(this, __a, _);
|
|
}
|
|
}
|
|
__a = new WeakMap();
|
|
class StaticNormal {
|
|
static accessor a = b;
|
|
static {
|
|
this.c = d;
|
|
}
|
|
}
|
|
class StaticPrivate {
|
|
static accessor #a = b;
|
|
static {
|
|
this.c = d;
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestJavaScriptDecoratorsBundleIssue3768
|
|
---------- /out/base-instance-accessor.js ----------
|
|
// base-instance-accessor.js
|
|
var _foo_dec, _init, _foo;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
constructor() {
|
|
__privateAdd(this, _foo, __runInitializers(_init, 8, this, _Foo)), __runInitializers(_init, 11, this);
|
|
}
|
|
};
|
|
_init = __decoratorStart(null);
|
|
_foo = new WeakMap();
|
|
__decorateElement(_init, 4, "foo", _foo_dec, _Foo, _foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/base-instance-field.js ----------
|
|
// base-instance-field.js
|
|
var _foo_dec, _init;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
constructor() {
|
|
__publicField(this, "foo", __runInitializers(_init, 8, this, _Foo)), __runInitializers(_init, 11, this);
|
|
}
|
|
};
|
|
_init = __decoratorStart(null);
|
|
__decorateElement(_init, 5, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/base-instance-method.js ----------
|
|
// base-instance-method.js
|
|
var _foo_dec, _init;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
constructor() {
|
|
__runInitializers(_init, 5, this);
|
|
}
|
|
foo() {
|
|
return _Foo;
|
|
}
|
|
};
|
|
_init = __decoratorStart(null);
|
|
__decorateElement(_init, 1, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/base-static-accessor.js ----------
|
|
// base-static-accessor.js
|
|
var _foo_dec, _init, _foo;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
};
|
|
_init = __decoratorStart(null);
|
|
_foo = new WeakMap();
|
|
__decorateElement(_init, 12, "foo", _foo_dec, _Foo, _foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__privateAdd(_Foo, _foo, __runInitializers(_init, 8, _Foo, _Foo)), __runInitializers(_init, 11, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/base-static-field.js ----------
|
|
// base-static-field.js
|
|
var _foo_dec, _init;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
};
|
|
_init = __decoratorStart(null);
|
|
__decorateElement(_init, 13, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__publicField(_Foo, "foo", __runInitializers(_init, 8, _Foo, _Foo)), __runInitializers(_init, 11, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/base-static-method.js ----------
|
|
// base-static-method.js
|
|
var _foo_dec, _init;
|
|
_foo_dec = [dec];
|
|
var _Foo = class _Foo {
|
|
static foo() {
|
|
return _Foo;
|
|
}
|
|
};
|
|
_init = __decoratorStart(null);
|
|
__decorateElement(_init, 9, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__runInitializers(_init, 3, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-instance-accessor.js ----------
|
|
// derived-instance-accessor.js
|
|
var _foo_dec, _a, _init, _foo;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _foo, __runInitializers(_init, 8, this, _Foo)), __runInitializers(_init, 11, this);
|
|
}
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
_foo = new WeakMap();
|
|
__decorateElement(_init, 4, "foo", _foo_dec, _Foo, _foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-instance-field.js ----------
|
|
// derived-instance-field.js
|
|
var _foo_dec, _a, _init;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "foo", __runInitializers(_init, 8, this, _Foo)), __runInitializers(_init, 11, this);
|
|
}
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
__decorateElement(_init, 5, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-instance-method.js ----------
|
|
// derived-instance-method.js
|
|
var _foo_dec, _a, _init;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
constructor() {
|
|
super(...arguments);
|
|
__runInitializers(_init, 5, this);
|
|
}
|
|
foo() {
|
|
return _Foo;
|
|
}
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
__decorateElement(_init, 1, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-static-accessor.js ----------
|
|
// derived-static-accessor.js
|
|
var _foo_dec, _a, _init, _foo;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
_foo = new WeakMap();
|
|
__decorateElement(_init, 12, "foo", _foo_dec, _Foo, _foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__privateAdd(_Foo, _foo, __runInitializers(_init, 8, _Foo, _Foo)), __runInitializers(_init, 11, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-static-field.js ----------
|
|
// derived-static-field.js
|
|
var _foo_dec, _a, _init;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
__decorateElement(_init, 13, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__publicField(_Foo, "foo", __runInitializers(_init, 8, _Foo, _Foo)), __runInitializers(_init, 11, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
---------- /out/derived-static-method.js ----------
|
|
// derived-static-method.js
|
|
var _foo_dec, _a, _init;
|
|
var _Foo = class _Foo extends (_a = Bar, _foo_dec = [dec], _a) {
|
|
static foo() {
|
|
return _Foo;
|
|
}
|
|
};
|
|
_init = __decoratorStart(_a);
|
|
__decorateElement(_init, 9, "foo", _foo_dec, _Foo);
|
|
__decoratorMetadata(_init, _Foo);
|
|
__runInitializers(_init, 3, _Foo);
|
|
var Foo = _Foo;
|
|
|
|
================================================================================
|
|
TestJavaScriptDecoratorsESNext
|
|
---------- /out.js ----------
|
|
@x.y()
|
|
@(new y.x())
|
|
export default class Foo {
|
|
@x @y mUndef;
|
|
@x @y mDef = 1;
|
|
@x @y method() {
|
|
return new Foo();
|
|
}
|
|
@x @y static sUndef;
|
|
@x @y static sDef = new Foo();
|
|
@x @y static sMethod() {
|
|
return new Foo();
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerAsync2016NoBundle
|
|
---------- /out.js ----------
|
|
function foo(_0) {
|
|
return __async(this, arguments, function* (bar) {
|
|
yield bar;
|
|
return [this, arguments];
|
|
});
|
|
}
|
|
class Foo {
|
|
foo() {
|
|
return __async(this, null, function* () {
|
|
});
|
|
}
|
|
}
|
|
new class Bar extends class {
|
|
} {
|
|
constructor() {
|
|
let x = 1;
|
|
(() => __async(null, null, function* () {
|
|
console.log("before super", x);
|
|
yield 1;
|
|
console.log("after super", x);
|
|
}))();
|
|
super();
|
|
x = 2;
|
|
}
|
|
}();
|
|
export default [
|
|
foo,
|
|
Foo,
|
|
function() {
|
|
return __async(this, null, function* () {
|
|
});
|
|
},
|
|
() => __async(null, null, function* () {
|
|
}),
|
|
{ foo() {
|
|
return __async(this, null, function* () {
|
|
});
|
|
} },
|
|
class {
|
|
foo() {
|
|
return __async(this, null, function* () {
|
|
});
|
|
}
|
|
},
|
|
function() {
|
|
var _arguments = arguments;
|
|
return (bar) => __async(this, null, function* () {
|
|
yield bar;
|
|
return [this, _arguments];
|
|
});
|
|
}
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerAsync2017NoBundle
|
|
---------- /out.js ----------
|
|
async function foo(bar) {
|
|
await bar;
|
|
return arguments;
|
|
}
|
|
class Foo {
|
|
async foo() {
|
|
}
|
|
}
|
|
export default [
|
|
foo,
|
|
Foo,
|
|
async function() {
|
|
},
|
|
async () => {
|
|
},
|
|
{ async foo() {
|
|
} },
|
|
class {
|
|
async foo() {
|
|
}
|
|
},
|
|
function() {
|
|
return async (bar) => {
|
|
await bar;
|
|
return [this, arguments];
|
|
};
|
|
}
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerAsyncArrowSuperES2016
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var foo1_default = class _foo1_default extends x {
|
|
foo1() {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_foo1_default.prototype, this, "foo").call(this, "foo1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo2.js
|
|
var foo2_default = class _foo2_default extends x {
|
|
foo2() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __superGet(_foo2_default.prototype, this, "foo").call(this, "foo2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo3.js
|
|
var foo3_default = class _foo3_default extends x {
|
|
foo3() {
|
|
return () => () => __async(null, null, function* () {
|
|
return __superGet(_foo3_default.prototype, this, "foo").call(this, "foo3");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo4.js
|
|
var foo4_default = class _foo4_default extends x {
|
|
foo4() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_foo4_default.prototype, this, "foo").call(this, "foo4");
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// bar1.js
|
|
var bar1_default = class _bar1_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar1", () => __async(null, null, function* () {
|
|
return __superGet(_bar1_default.prototype, this, "foo").call(this, "bar1");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar2.js
|
|
var bar2_default = class _bar2_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar2", () => __async(null, null, function* () {
|
|
return () => __superGet(_bar2_default.prototype, this, "foo").call(this, "bar2");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar3.js
|
|
var bar3_default = class _bar3_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar3", () => () => __async(null, null, function* () {
|
|
return __superGet(_bar3_default.prototype, this, "foo").call(this, "bar3");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar4.js
|
|
var bar4_default = class _bar4_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar4", () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_bar4_default.prototype, this, "foo").call(this, "bar4");
|
|
});
|
|
}));
|
|
}
|
|
};
|
|
|
|
// baz1.js
|
|
var baz1_default = class _baz1_default extends x {
|
|
baz1() {
|
|
return __async(this, null, function* () {
|
|
return () => __superGet(_baz1_default.prototype, this, "foo").call(this, "baz1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// baz2.js
|
|
var baz2_default = class _baz2_default extends x {
|
|
baz2() {
|
|
return __async(this, null, function* () {
|
|
return () => () => __superGet(_baz2_default.prototype, this, "foo").call(this, "baz2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// outer.js
|
|
var outer_default = (function() {
|
|
return __async(this, null, function* () {
|
|
class y extends z {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "foo", () => __async(null, null, function* () {
|
|
return __superGet(y.prototype, this, "foo").call(this);
|
|
}));
|
|
}
|
|
}
|
|
yield new y().foo()();
|
|
});
|
|
})();
|
|
export {
|
|
bar1_default as bar1,
|
|
bar2_default as bar2,
|
|
bar3_default as bar3,
|
|
bar4_default as bar4,
|
|
baz1_default as baz1,
|
|
baz2_default as baz2,
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerAsyncArrowSuperSetterES2016
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var foo1_default = class _foo1_default extends x {
|
|
foo1() {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_foo1_default.prototype, this, "foo", "foo1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo2.js
|
|
var foo2_default = class _foo2_default extends x {
|
|
foo2() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __superSet(_foo2_default.prototype, this, "foo", "foo2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo3.js
|
|
var foo3_default = class _foo3_default extends x {
|
|
foo3() {
|
|
return () => () => __async(null, null, function* () {
|
|
return __superSet(_foo3_default.prototype, this, "foo", "foo3");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo4.js
|
|
var foo4_default = class _foo4_default extends x {
|
|
foo4() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_foo4_default.prototype, this, "foo", "foo4");
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// bar1.js
|
|
var bar1_default = class _bar1_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar1", () => __async(null, null, function* () {
|
|
return __superSet(_bar1_default.prototype, this, "foo", "bar1");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar2.js
|
|
var bar2_default = class _bar2_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar2", () => __async(null, null, function* () {
|
|
return () => __superSet(_bar2_default.prototype, this, "foo", "bar2");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar3.js
|
|
var bar3_default = class _bar3_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar3", () => () => __async(null, null, function* () {
|
|
return __superSet(_bar3_default.prototype, this, "foo", "bar3");
|
|
}));
|
|
}
|
|
};
|
|
|
|
// bar4.js
|
|
var bar4_default = class _bar4_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "bar4", () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_bar4_default.prototype, this, "foo", "bar4");
|
|
});
|
|
}));
|
|
}
|
|
};
|
|
|
|
// baz1.js
|
|
var baz1_default = class _baz1_default extends x {
|
|
baz1() {
|
|
return __async(this, null, function* () {
|
|
return () => __superSet(_baz1_default.prototype, this, "foo", "baz1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// baz2.js
|
|
var baz2_default = class _baz2_default extends x {
|
|
baz2() {
|
|
return __async(this, null, function* () {
|
|
return () => () => __superSet(_baz2_default.prototype, this, "foo", "baz2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// outer.js
|
|
var outer_default = (function() {
|
|
return __async(this, null, function* () {
|
|
class y extends z {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "foo", () => __async(null, null, function* () {
|
|
return __superSet(y.prototype, this, "foo", "foo");
|
|
}));
|
|
}
|
|
}
|
|
yield new y().foo()();
|
|
});
|
|
})();
|
|
export {
|
|
bar1_default as bar1,
|
|
bar2_default as bar2,
|
|
bar3_default as bar3,
|
|
bar4_default as bar4,
|
|
baz1_default as baz1,
|
|
baz2_default as baz2,
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerAsyncGenerator
|
|
---------- /out/entry.js ----------
|
|
function foo() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
foo = function() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
};
|
|
foo = { bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
} };
|
|
class Foo {
|
|
bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
Foo = class {
|
|
bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
async function bar() {
|
|
await using x = await y;
|
|
for await (let x2 of y) {
|
|
}
|
|
for await (await using x2 of y) {
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerAsyncGeneratorNoAwait
|
|
---------- /out/entry.js ----------
|
|
function foo() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
foo = function() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
};
|
|
foo = { bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
} };
|
|
class Foo {
|
|
bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
Foo = class {
|
|
bar() {
|
|
return __asyncGenerator(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
yield;
|
|
yield x;
|
|
yield* __yieldStar(x);
|
|
const x = __using(_stack2, yield new __await(y), true);
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
|
|
let x2 = temp.value;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield new __await(temp.call(iter)));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
try {
|
|
for (var iter2 = __forAwait(y), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
|
|
var _x = temp2.value;
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield new __await(_promise));
|
|
}
|
|
}
|
|
} catch (temp2) {
|
|
error2 = [temp2];
|
|
} finally {
|
|
try {
|
|
more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
|
|
} finally {
|
|
if (error2)
|
|
throw error2[0];
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield new __await(_promise2));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
function bar() {
|
|
return __async(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
const x = __using(_stack2, yield y, true);
|
|
for await (let x2 of y) {
|
|
}
|
|
for await (var _x of y) {
|
|
var _stack = [];
|
|
try {
|
|
const x2 = __using(_stack, _x, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield _promise);
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield _promise2);
|
|
}
|
|
});
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerAsyncSuperES2016NoBundle
|
|
---------- /out.js ----------
|
|
class Derived extends Base {
|
|
test(key) {
|
|
return __async(this, null, function* () {
|
|
var _a, _b, _c, _d;
|
|
return [
|
|
yield __superGet(Derived.prototype, this, "foo"),
|
|
yield __superGet(Derived.prototype, this, key),
|
|
yield [__superWrapper(Derived.prototype, this, "foo")._] = [0],
|
|
yield [__superWrapper(Derived.prototype, this, key)._] = [0],
|
|
yield __superSet(Derived.prototype, this, "foo", 1),
|
|
yield __superSet(Derived.prototype, this, key, 1),
|
|
yield __superSet(Derived.prototype, this, "foo", __superGet(Derived.prototype, this, "foo") + 2),
|
|
yield __superSet(Derived.prototype, this, key, __superGet(Derived.prototype, this, key) + 2),
|
|
yield ++__superWrapper(Derived.prototype, this, "foo")._,
|
|
yield ++__superWrapper(Derived.prototype, this, key)._,
|
|
yield __superWrapper(Derived.prototype, this, "foo")._++,
|
|
yield __superWrapper(Derived.prototype, this, key)._++,
|
|
yield __superGet(Derived.prototype, this, "foo").name,
|
|
yield __superGet(Derived.prototype, this, key).name,
|
|
yield (_a = __superGet(Derived.prototype, this, "foo")) == null ? void 0 : _a.name,
|
|
yield (_b = __superGet(Derived.prototype, this, key)) == null ? void 0 : _b.name,
|
|
yield __superGet(Derived.prototype, this, "foo").call(this, 1, 2),
|
|
yield __superGet(Derived.prototype, this, key).call(this, 1, 2),
|
|
yield (_c = __superGet(Derived.prototype, this, "foo")) == null ? void 0 : _c.call(this, 1, 2),
|
|
yield (_d = __superGet(Derived.prototype, this, key)) == null ? void 0 : _d.call(this, 1, 2),
|
|
yield (() => __superGet(Derived.prototype, this, "foo"))(),
|
|
yield (() => __superGet(Derived.prototype, this, key))(),
|
|
yield (() => __superGet(Derived.prototype, this, "foo").call(this))(),
|
|
yield (() => __superGet(Derived.prototype, this, key).call(this))(),
|
|
yield __superGet(Derived.prototype, this, "foo").bind(this)``,
|
|
yield __superGet(Derived.prototype, this, key).bind(this)``
|
|
];
|
|
});
|
|
}
|
|
}
|
|
let fn = () => __async(null, null, function* () {
|
|
return class extends Base {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "a", super.a);
|
|
__publicField(this, "b", () => super.b);
|
|
}
|
|
c() {
|
|
return super.c;
|
|
}
|
|
d() {
|
|
return () => super.d;
|
|
}
|
|
};
|
|
});
|
|
class Derived2 extends Base {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "b", () => __async(null, null, function* () {
|
|
var _a;
|
|
return _a = __superGet(Derived2.prototype, this, "foo"), class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
}));
|
|
}
|
|
a() {
|
|
return __async(this, null, function* () {
|
|
var _a;
|
|
return _a = __superGet(Derived2.prototype, this, "foo"), class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
}
|
|
for (let i = 0; i < 3; i++) {
|
|
let _a;
|
|
objs.push(_a = {
|
|
__proto__: {
|
|
foo() {
|
|
return i;
|
|
}
|
|
},
|
|
bar() {
|
|
return __async(this, null, function* () {
|
|
return __superGet(_a, this, "foo").call(this);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerAsyncSuperES2017NoBundle
|
|
---------- /out.js ----------
|
|
class Derived extends Base {
|
|
async test(key) {
|
|
var _a, _b, _c, _d;
|
|
return [
|
|
await super.foo,
|
|
await super[key],
|
|
await ([super.foo] = [0]),
|
|
await ([super[key]] = [0]),
|
|
await (super.foo = 1),
|
|
await (super[key] = 1),
|
|
await (super.foo += 2),
|
|
await (super[key] += 2),
|
|
await ++super.foo,
|
|
await ++super[key],
|
|
await super.foo++,
|
|
await super[key]++,
|
|
await super.foo.name,
|
|
await super[key].name,
|
|
await ((_a = super.foo) == null ? void 0 : _a.name),
|
|
await ((_b = super[key]) == null ? void 0 : _b.name),
|
|
await super.foo(1, 2),
|
|
await super[key](1, 2),
|
|
await ((_c = super.foo) == null ? void 0 : _c.call(this, 1, 2)),
|
|
await ((_d = super[key]) == null ? void 0 : _d.call(this, 1, 2)),
|
|
await (() => super.foo)(),
|
|
await (() => super[key])(),
|
|
await (() => super.foo())(),
|
|
await (() => super[key]())(),
|
|
await super.foo``,
|
|
await super[key]``
|
|
];
|
|
}
|
|
}
|
|
let fn = async () => class extends Base {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "a", super.a);
|
|
__publicField(this, "b", () => super.b);
|
|
}
|
|
c() {
|
|
return super.c;
|
|
}
|
|
d() {
|
|
return () => super.d;
|
|
}
|
|
};
|
|
class Derived2 extends Base {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "b", async () => {
|
|
var _a;
|
|
return _a = super.foo, class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
async a() {
|
|
var _a;
|
|
return _a = super.foo, class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
for (let i = 0; i < 3; i++) {
|
|
objs.push({
|
|
__proto__: {
|
|
foo() {
|
|
return i;
|
|
}
|
|
},
|
|
async bar() {
|
|
return super.foo();
|
|
}
|
|
});
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerAsyncThis2016CommonJS
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var require_entry = __commonJS({
|
|
"entry.js"(exports) {
|
|
exports.foo = () => __async(exports, null, function* () {
|
|
return exports;
|
|
});
|
|
}
|
|
});
|
|
export default require_entry();
|
|
|
|
================================================================================
|
|
TestLowerAsyncThis2016ES6
|
|
---------- /out.js ----------
|
|
// other.js
|
|
var bar = () => __async(null, null, function* () {
|
|
});
|
|
|
|
// entry.js
|
|
var foo = () => __async(void 0, null, function* () {
|
|
return void 0;
|
|
});
|
|
export {
|
|
bar,
|
|
foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerClassField2020NoBundle
|
|
---------- /out.js ----------
|
|
var _foo, _bar, _s_foo, _s_bar;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _foo, 123);
|
|
__privateAdd(this, _bar);
|
|
__publicField(this, "foo", 123);
|
|
__publicField(this, "bar");
|
|
}
|
|
}
|
|
_foo = new WeakMap();
|
|
_bar = new WeakMap();
|
|
_s_foo = new WeakMap();
|
|
_s_bar = new WeakMap();
|
|
__privateAdd(Foo, _s_foo, 123);
|
|
__privateAdd(Foo, _s_bar);
|
|
__publicField(Foo, "s_foo", 123);
|
|
__publicField(Foo, "s_bar");
|
|
|
|
================================================================================
|
|
TestLowerClassFieldNextNoBundle
|
|
---------- /out.js ----------
|
|
class Foo {
|
|
#foo = 123;
|
|
#bar;
|
|
foo = 123;
|
|
bar;
|
|
static #s_foo = 123;
|
|
static #s_bar;
|
|
static s_foo = 123;
|
|
static s_bar;
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerClassFieldStrictTsconfigJson2020
|
|
---------- /out.js ----------
|
|
// loose/index.js
|
|
var loose_default = class {
|
|
constructor() {
|
|
__publicField(this, "foo");
|
|
}
|
|
};
|
|
|
|
// strict/index.js
|
|
var strict_default = class {
|
|
constructor() {
|
|
__publicField(this, "foo");
|
|
}
|
|
};
|
|
|
|
// entry.js
|
|
console.log(loose_default, strict_default);
|
|
|
|
================================================================================
|
|
TestLowerConstIssue4448
|
|
---------- /out.js ----------
|
|
var import_meta = {};
|
|
var x = require("fs");
|
|
console.log(import_meta.foo(x));
|
|
|
|
================================================================================
|
|
TestLowerExponentiationOperatorNoBundle
|
|
---------- /out.js ----------
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
|
|
let tests = {
|
|
// Exponentiation operator
|
|
0: __pow(a, __pow(b, c)),
|
|
1: __pow(__pow(a, b), c),
|
|
// Exponentiation assignment operator
|
|
2: a = __pow(a, b),
|
|
3: a.b = __pow(a.b, c),
|
|
4: a[b] = __pow(a[b], c),
|
|
5: (_a = a()).b = __pow(_a.b, c),
|
|
6: (_b = a())[b] = __pow(_b[b], c),
|
|
7: a[_c = b()] = __pow(a[_c], c),
|
|
8: (_d = a())[_e = b()] = __pow(_d[_e], c),
|
|
// These all should not need capturing (no object identity)
|
|
9: a[0] = __pow(a[0], b),
|
|
10: a[false] = __pow(a[false], b),
|
|
11: a[null] = __pow(a[null], b),
|
|
12: a[void 0] = __pow(a[void 0], b),
|
|
13: a[/* @__PURE__ */ BigInt("123")] = __pow(a[/* @__PURE__ */ BigInt("123")], b),
|
|
14: a[this] = __pow(a[this], b),
|
|
// These should need capturing (have object identity)
|
|
15: a[_f = /x/] = __pow(a[_f], b),
|
|
16: a[_g = {}] = __pow(a[_g], b),
|
|
17: a[_h = []] = __pow(a[_h], b),
|
|
18: a[_i = () => {
|
|
}] = __pow(a[_i], b),
|
|
19: a[_j = function() {
|
|
}] = __pow(a[_j], b)
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerExportStarAsNameCollision
|
|
---------- /out.js ----------
|
|
// nested.js
|
|
import * as foo from "path2";
|
|
var foo2 = 123;
|
|
|
|
// entry.js
|
|
import * as ns from "path1";
|
|
console.log(foo, foo2);
|
|
var ns2 = 123;
|
|
export {
|
|
ns,
|
|
ns2 as sn
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerExportStarAsNameCollisionNoBundle
|
|
---------- /out.js ----------
|
|
import * as ns from "path";
|
|
export { ns };
|
|
let ns2 = 123;
|
|
export { ns2 as sn };
|
|
|
|
================================================================================
|
|
TestLowerForAwait2015
|
|
---------- /out.js ----------
|
|
export default [
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
x = temp.value;
|
|
z(x);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}),
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
x.y = temp.value;
|
|
z(x);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}),
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
let x2 = temp.value;
|
|
z(x2);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}),
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
z(x2);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}),
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
label: for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
break label;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}),
|
|
() => __async(null, null, function* () {
|
|
try {
|
|
label: for (var iter = __forAwait(y), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
continue label;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && (yield temp.call(iter));
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
})
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerForAwait2017
|
|
---------- /out.js ----------
|
|
export default [
|
|
async () => {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
x = temp.value;
|
|
z(x);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
},
|
|
async () => {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
x.y = temp.value;
|
|
z(x);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
},
|
|
async () => {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
let x2 = temp.value;
|
|
z(x2);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
},
|
|
async () => {
|
|
try {
|
|
for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
z(x2);
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
},
|
|
async () => {
|
|
try {
|
|
label: for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
break label;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
},
|
|
async () => {
|
|
try {
|
|
label: for (var iter = __forAwait(y), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
|
|
const x2 = temp.value;
|
|
continue label;
|
|
}
|
|
} catch (temp) {
|
|
error = [temp];
|
|
} finally {
|
|
try {
|
|
more && (temp = iter.return) && await temp.call(iter);
|
|
} finally {
|
|
if (error)
|
|
throw error[0];
|
|
}
|
|
}
|
|
}
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerNestedFunctionDirectEval
|
|
---------- /out/1.js ----------
|
|
if (foo) {
|
|
let x2 = function() {
|
|
};
|
|
var x = x2;
|
|
}
|
|
|
|
---------- /out/2.js ----------
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
eval("");
|
|
}
|
|
|
|
---------- /out/3.js ----------
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
if (bar) {
|
|
eval("");
|
|
}
|
|
}
|
|
|
|
---------- /out/4.js ----------
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
eval("");
|
|
}
|
|
|
|
---------- /out/5.js ----------
|
|
"use strict";
|
|
if (foo) {
|
|
let x = function() {
|
|
};
|
|
}
|
|
|
|
---------- /out/6.js ----------
|
|
"use strict";
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
eval("");
|
|
}
|
|
|
|
---------- /out/7.js ----------
|
|
"use strict";
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
if (bar) {
|
|
eval("");
|
|
}
|
|
}
|
|
|
|
---------- /out/8.js ----------
|
|
"use strict";
|
|
if (foo) {
|
|
function x() {
|
|
}
|
|
eval("");
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerNullishCoalescingAssignmentIssue1493
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var A = class {
|
|
#a;
|
|
f() {
|
|
this.#a ?? (this.#a = 1);
|
|
}
|
|
};
|
|
export {
|
|
A
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerObjectSpreadNoBundle
|
|
---------- /out.js ----------
|
|
let tests = [
|
|
__spreadValues(__spreadValues({}, a), b),
|
|
__spreadValues({ a, b }, c),
|
|
__spreadProps(__spreadValues({}, a), { b, c }),
|
|
__spreadProps(__spreadValues({ a }, b), { c }),
|
|
__spreadProps(__spreadValues(__spreadValues(__spreadProps(__spreadValues(__spreadValues({ a, b }, c), d), { e, f }), g), h), { i, j })
|
|
];
|
|
let jsx = [
|
|
/* @__PURE__ */ React.createElement("div", __spreadValues(__spreadValues({}, a), b)),
|
|
/* @__PURE__ */ React.createElement("div", __spreadValues({ a: true, b: true }, c)),
|
|
/* @__PURE__ */ React.createElement("div", __spreadProps(__spreadValues({}, a), { b: true, c: true })),
|
|
/* @__PURE__ */ React.createElement("div", __spreadProps(__spreadValues({ a: true }, b), { c: true })),
|
|
/* @__PURE__ */ React.createElement("div", __spreadProps(__spreadValues(__spreadValues(__spreadProps(__spreadValues(__spreadValues({ a: true, b: true }, c), d), { e: true, f: true }), g), h), { i: true, j: true }))
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerOptionalCatchNameCollisionNoBundle
|
|
---------- /out.js ----------
|
|
try {
|
|
} catch (e4) {
|
|
var e, e2;
|
|
}
|
|
var e3;
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassAccessorOrder
|
|
---------- /out.js ----------
|
|
var _Foo_instances, foo_get;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__publicField(this, "bar", __privateGet(this, _Foo_instances, foo_get));
|
|
}
|
|
// This must be set before "bar" is initialized
|
|
}
|
|
_Foo_instances = new WeakSet();
|
|
foo_get = function() {
|
|
return 123;
|
|
};
|
|
console.log(new Foo().bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassBrandCheckSupported
|
|
---------- /out.js ----------
|
|
class Foo {
|
|
#foo;
|
|
#bar;
|
|
baz() {
|
|
return [
|
|
this.#foo,
|
|
this.#bar,
|
|
#foo in this
|
|
];
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassBrandCheckUnsupported
|
|
---------- /out.js ----------
|
|
var _foo;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _foo);
|
|
this.#bar = void 0;
|
|
}
|
|
#bar;
|
|
baz() {
|
|
return [
|
|
__privateGet(this, _foo),
|
|
this.#bar,
|
|
__privateIn(_foo, this)
|
|
];
|
|
}
|
|
}
|
|
_foo = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassExpr2020NoBundle
|
|
---------- /out.js ----------
|
|
var _field, _Foo_instances, method_fn, _a, _staticField, _Foo_static, staticMethod_fn;
|
|
export let Foo = (_a = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _field);
|
|
}
|
|
foo() {
|
|
var _a2;
|
|
__privateSet(this, _field, __privateMethod(this, _Foo_instances, method_fn).call(this));
|
|
__privateSet(Foo, _staticField, __privateMethod(_a2 = Foo, _Foo_static, staticMethod_fn).call(_a2));
|
|
}
|
|
}, _field = new WeakMap(), _Foo_instances = new WeakSet(), method_fn = function() {
|
|
}, _staticField = new WeakMap(), _Foo_static = new WeakSet(), staticMethod_fn = function() {
|
|
}, __privateAdd(_a, _Foo_static), __privateAdd(_a, _staticField), _a);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassFieldOrder
|
|
---------- /out.js ----------
|
|
var _foo;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _foo, 123);
|
|
// This must be set before "bar" is initialized
|
|
__publicField(this, "bar", __privateGet(this, _foo));
|
|
}
|
|
}
|
|
_foo = new WeakMap();
|
|
console.log(new Foo().bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassFieldStaticIssue1424
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _T_instances, a_fn, b_fn;
|
|
var T = class {
|
|
constructor() {
|
|
__privateAdd(this, _T_instances);
|
|
}
|
|
d() {
|
|
console.log(__privateMethod(this, _T_instances, a_fn).call(this));
|
|
}
|
|
};
|
|
_T_instances = new WeakSet();
|
|
a_fn = function() {
|
|
return "a";
|
|
};
|
|
b_fn = function() {
|
|
return "b";
|
|
};
|
|
__publicField(T, "c");
|
|
new T().d();
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassMethodOrder
|
|
---------- /out.js ----------
|
|
var _Foo_instances, foo_fn;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__publicField(this, "bar", __privateMethod(this, _Foo_instances, foo_fn).call(this));
|
|
}
|
|
// This must be set before "bar" is initialized
|
|
}
|
|
_Foo_instances = new WeakSet();
|
|
foo_fn = function() {
|
|
return 123;
|
|
};
|
|
console.log(new Foo().bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassStaticAccessorOrder
|
|
---------- /out.js ----------
|
|
var _Foo_static, foo_get, _FooThis_static, foo_get2;
|
|
const _Foo = class _Foo {
|
|
// This must be set before "bar" is initialized
|
|
};
|
|
_Foo_static = new WeakSet();
|
|
foo_get = function() {
|
|
return 123;
|
|
};
|
|
__privateAdd(_Foo, _Foo_static);
|
|
__publicField(_Foo, "bar", __privateGet(_Foo, _Foo_static, foo_get));
|
|
let Foo = _Foo;
|
|
console.log(Foo.bar === 123);
|
|
const _FooThis = class _FooThis {
|
|
// This must be set before "bar" is initialized
|
|
};
|
|
_FooThis_static = new WeakSet();
|
|
foo_get2 = function() {
|
|
return 123;
|
|
};
|
|
__privateAdd(_FooThis, _FooThis_static);
|
|
__publicField(_FooThis, "bar", __privateGet(_FooThis, _FooThis_static, foo_get2));
|
|
let FooThis = _FooThis;
|
|
console.log(FooThis.bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassStaticFieldOrder
|
|
---------- /out.js ----------
|
|
var _foo, _foo2;
|
|
const _Foo = class _Foo {
|
|
};
|
|
_foo = new WeakMap();
|
|
__privateAdd(_Foo, _foo, 123);
|
|
// This must be set before "bar" is initialized
|
|
__publicField(_Foo, "bar", __privateGet(_Foo, _foo));
|
|
let Foo = _Foo;
|
|
console.log(Foo.bar === 123);
|
|
const _FooThis = class _FooThis {
|
|
};
|
|
_foo2 = new WeakMap();
|
|
__privateAdd(_FooThis, _foo2, 123);
|
|
// This must be set before "bar" is initialized
|
|
__publicField(_FooThis, "bar", __privateGet(_FooThis, _foo2));
|
|
let FooThis = _FooThis;
|
|
console.log(FooThis.bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateClassStaticMethodOrder
|
|
---------- /out.js ----------
|
|
var _a, _Foo_static, foo_fn, _b, _FooThis_static, foo_fn2;
|
|
const _Foo = class _Foo {
|
|
// This must be set before "bar" is initialized
|
|
};
|
|
_Foo_static = new WeakSet();
|
|
foo_fn = function() {
|
|
return 123;
|
|
};
|
|
__privateAdd(_Foo, _Foo_static);
|
|
__publicField(_Foo, "bar", __privateMethod(_a = _Foo, _Foo_static, foo_fn).call(_a));
|
|
let Foo = _Foo;
|
|
console.log(Foo.bar === 123);
|
|
const _FooThis = class _FooThis {
|
|
// This must be set before "bar" is initialized
|
|
};
|
|
_FooThis_static = new WeakSet();
|
|
foo_fn2 = function() {
|
|
return 123;
|
|
};
|
|
__privateAdd(_FooThis, _FooThis_static);
|
|
__publicField(_FooThis, "bar", __privateMethod(_b = _FooThis, _FooThis_static, foo_fn2).call(_b));
|
|
let FooThis = _FooThis;
|
|
console.log(FooThis.bar === 123);
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldAssignments2015NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
unary() {
|
|
__privateWrapper(this, _x)._++;
|
|
__privateWrapper(this, _x)._--;
|
|
++__privateWrapper(this, _x)._;
|
|
--__privateWrapper(this, _x)._;
|
|
}
|
|
binary() {
|
|
var _a;
|
|
__privateSet(this, _x, 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) + 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) - 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) * 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) / 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) % 1);
|
|
__privateSet(this, _x, __pow(__privateGet(this, _x), 1));
|
|
__privateSet(this, _x, __privateGet(this, _x) << 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >>> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) & 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) | 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) ^ 1);
|
|
__privateGet(this, _x) && __privateSet(this, _x, 1);
|
|
__privateGet(this, _x) || __privateSet(this, _x, 1);
|
|
(_a = __privateGet(this, _x)) != null ? _a : __privateSet(this, _x, 1);
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldAssignments2019NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
unary() {
|
|
__privateWrapper(this, _x)._++;
|
|
__privateWrapper(this, _x)._--;
|
|
++__privateWrapper(this, _x)._;
|
|
--__privateWrapper(this, _x)._;
|
|
}
|
|
binary() {
|
|
var _a;
|
|
__privateSet(this, _x, 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) + 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) - 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) * 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) / 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) % 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) ** 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) << 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >>> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) & 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) | 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) ^ 1);
|
|
__privateGet(this, _x) && __privateSet(this, _x, 1);
|
|
__privateGet(this, _x) || __privateSet(this, _x, 1);
|
|
(_a = __privateGet(this, _x)) != null ? _a : __privateSet(this, _x, 1);
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldAssignments2020NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
unary() {
|
|
__privateWrapper(this, _x)._++;
|
|
__privateWrapper(this, _x)._--;
|
|
++__privateWrapper(this, _x)._;
|
|
--__privateWrapper(this, _x)._;
|
|
}
|
|
binary() {
|
|
__privateSet(this, _x, 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) + 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) - 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) * 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) / 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) % 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) ** 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) << 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) >>> 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) & 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) | 1);
|
|
__privateSet(this, _x, __privateGet(this, _x) ^ 1);
|
|
__privateGet(this, _x) && __privateSet(this, _x, 1);
|
|
__privateGet(this, _x) || __privateSet(this, _x, 1);
|
|
__privateGet(this, _x) ?? __privateSet(this, _x, 1);
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldAssignmentsNextNoBundle
|
|
---------- /out.js ----------
|
|
class Foo {
|
|
#x;
|
|
unary() {
|
|
this.#x++;
|
|
this.#x--;
|
|
++this.#x;
|
|
--this.#x;
|
|
}
|
|
binary() {
|
|
this.#x = 1;
|
|
this.#x += 1;
|
|
this.#x -= 1;
|
|
this.#x *= 1;
|
|
this.#x /= 1;
|
|
this.#x %= 1;
|
|
this.#x **= 1;
|
|
this.#x <<= 1;
|
|
this.#x >>= 1;
|
|
this.#x >>>= 1;
|
|
this.#x &= 1;
|
|
this.#x |= 1;
|
|
this.#x ^= 1;
|
|
this.#x &&= 1;
|
|
this.#x ||= 1;
|
|
this.#x ??= 1;
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldOptionalChain2019NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
foo() {
|
|
var _a;
|
|
this == null ? void 0 : __privateGet(this, _x).y;
|
|
this == null ? void 0 : __privateGet(this.y, _x);
|
|
(_a = __privateGet(this, _x)) == null ? void 0 : _a.y;
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldOptionalChain2020NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
foo() {
|
|
this == null ? void 0 : __privateGet(this, _x).y;
|
|
this == null ? void 0 : __privateGet(this.y, _x);
|
|
__privateGet(this, _x)?.y;
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestLowerPrivateFieldOptionalChainNextNoBundle
|
|
---------- /out.js ----------
|
|
class Foo {
|
|
#x;
|
|
foo() {
|
|
this?.#x.y;
|
|
this?.y.#x;
|
|
this.#x?.y;
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerPrivateGetterSetter2015
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _Foo_instances, foo_get, bar_set, prop_get, prop_set;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
}
|
|
foo(fn) {
|
|
__privateGet(fn(), _Foo_instances, foo_get);
|
|
__privateSet(fn(), _Foo_instances, 1, bar_set);
|
|
__privateGet(fn(), _Foo_instances, prop_get);
|
|
__privateSet(fn(), _Foo_instances, 2, prop_set);
|
|
}
|
|
unary(fn) {
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._++;
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._--;
|
|
++__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
--__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
}
|
|
binary(fn) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
|
|
__privateSet(fn(), _Foo_instances, 1, prop_set);
|
|
__privateSet(_a = fn(), _Foo_instances, __privateGet(_a, _Foo_instances, prop_get) + 1, prop_set);
|
|
__privateSet(_b = fn(), _Foo_instances, __privateGet(_b, _Foo_instances, prop_get) - 1, prop_set);
|
|
__privateSet(_c = fn(), _Foo_instances, __privateGet(_c, _Foo_instances, prop_get) * 1, prop_set);
|
|
__privateSet(_d = fn(), _Foo_instances, __privateGet(_d, _Foo_instances, prop_get) / 1, prop_set);
|
|
__privateSet(_e = fn(), _Foo_instances, __privateGet(_e, _Foo_instances, prop_get) % 1, prop_set);
|
|
__privateSet(_f = fn(), _Foo_instances, __pow(__privateGet(_f, _Foo_instances, prop_get), 1), prop_set);
|
|
__privateSet(_g = fn(), _Foo_instances, __privateGet(_g, _Foo_instances, prop_get) << 1, prop_set);
|
|
__privateSet(_h = fn(), _Foo_instances, __privateGet(_h, _Foo_instances, prop_get) >> 1, prop_set);
|
|
__privateSet(_i = fn(), _Foo_instances, __privateGet(_i, _Foo_instances, prop_get) >>> 1, prop_set);
|
|
__privateSet(_j = fn(), _Foo_instances, __privateGet(_j, _Foo_instances, prop_get) & 1, prop_set);
|
|
__privateSet(_k = fn(), _Foo_instances, __privateGet(_k, _Foo_instances, prop_get) | 1, prop_set);
|
|
__privateSet(_l = fn(), _Foo_instances, __privateGet(_l, _Foo_instances, prop_get) ^ 1, prop_set);
|
|
__privateGet(_m = fn(), _Foo_instances, prop_get) && __privateSet(_m, _Foo_instances, 1, prop_set);
|
|
__privateGet(_n = fn(), _Foo_instances, prop_get) || __privateSet(_n, _Foo_instances, 1, prop_set);
|
|
(_p = __privateGet(_o = fn(), _Foo_instances, prop_get)) != null ? _p : __privateSet(_o, _Foo_instances, 1, prop_set);
|
|
}
|
|
};
|
|
_Foo_instances = new WeakSet();
|
|
foo_get = function() {
|
|
return this.foo;
|
|
};
|
|
bar_set = function(val) {
|
|
this.bar = val;
|
|
};
|
|
prop_get = function() {
|
|
return this.prop;
|
|
};
|
|
prop_set = function(val) {
|
|
this.prop = val;
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateGetterSetter2019
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _Foo_instances, foo_get, bar_set, prop_get, prop_set;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
}
|
|
foo(fn) {
|
|
__privateGet(fn(), _Foo_instances, foo_get);
|
|
__privateSet(fn(), _Foo_instances, 1, bar_set);
|
|
__privateGet(fn(), _Foo_instances, prop_get);
|
|
__privateSet(fn(), _Foo_instances, 2, prop_set);
|
|
}
|
|
unary(fn) {
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._++;
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._--;
|
|
++__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
--__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
}
|
|
binary(fn) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
|
|
__privateSet(fn(), _Foo_instances, 1, prop_set);
|
|
__privateSet(_a = fn(), _Foo_instances, __privateGet(_a, _Foo_instances, prop_get) + 1, prop_set);
|
|
__privateSet(_b = fn(), _Foo_instances, __privateGet(_b, _Foo_instances, prop_get) - 1, prop_set);
|
|
__privateSet(_c = fn(), _Foo_instances, __privateGet(_c, _Foo_instances, prop_get) * 1, prop_set);
|
|
__privateSet(_d = fn(), _Foo_instances, __privateGet(_d, _Foo_instances, prop_get) / 1, prop_set);
|
|
__privateSet(_e = fn(), _Foo_instances, __privateGet(_e, _Foo_instances, prop_get) % 1, prop_set);
|
|
__privateSet(_f = fn(), _Foo_instances, __privateGet(_f, _Foo_instances, prop_get) ** 1, prop_set);
|
|
__privateSet(_g = fn(), _Foo_instances, __privateGet(_g, _Foo_instances, prop_get) << 1, prop_set);
|
|
__privateSet(_h = fn(), _Foo_instances, __privateGet(_h, _Foo_instances, prop_get) >> 1, prop_set);
|
|
__privateSet(_i = fn(), _Foo_instances, __privateGet(_i, _Foo_instances, prop_get) >>> 1, prop_set);
|
|
__privateSet(_j = fn(), _Foo_instances, __privateGet(_j, _Foo_instances, prop_get) & 1, prop_set);
|
|
__privateSet(_k = fn(), _Foo_instances, __privateGet(_k, _Foo_instances, prop_get) | 1, prop_set);
|
|
__privateSet(_l = fn(), _Foo_instances, __privateGet(_l, _Foo_instances, prop_get) ^ 1, prop_set);
|
|
__privateGet(_m = fn(), _Foo_instances, prop_get) && __privateSet(_m, _Foo_instances, 1, prop_set);
|
|
__privateGet(_n = fn(), _Foo_instances, prop_get) || __privateSet(_n, _Foo_instances, 1, prop_set);
|
|
(_p = __privateGet(_o = fn(), _Foo_instances, prop_get)) != null ? _p : __privateSet(_o, _Foo_instances, 1, prop_set);
|
|
}
|
|
};
|
|
_Foo_instances = new WeakSet();
|
|
foo_get = function() {
|
|
return this.foo;
|
|
};
|
|
bar_set = function(val) {
|
|
this.bar = val;
|
|
};
|
|
prop_get = function() {
|
|
return this.prop;
|
|
};
|
|
prop_set = function(val) {
|
|
this.prop = val;
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateGetterSetter2020
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _Foo_instances, foo_get, bar_set, prop_get, prop_set;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
}
|
|
foo(fn) {
|
|
__privateGet(fn(), _Foo_instances, foo_get);
|
|
__privateSet(fn(), _Foo_instances, 1, bar_set);
|
|
__privateGet(fn(), _Foo_instances, prop_get);
|
|
__privateSet(fn(), _Foo_instances, 2, prop_set);
|
|
}
|
|
unary(fn) {
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._++;
|
|
__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._--;
|
|
++__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
--__privateWrapper(fn(), _Foo_instances, prop_set, prop_get)._;
|
|
}
|
|
binary(fn) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
|
|
__privateSet(fn(), _Foo_instances, 1, prop_set);
|
|
__privateSet(_a = fn(), _Foo_instances, __privateGet(_a, _Foo_instances, prop_get) + 1, prop_set);
|
|
__privateSet(_b = fn(), _Foo_instances, __privateGet(_b, _Foo_instances, prop_get) - 1, prop_set);
|
|
__privateSet(_c = fn(), _Foo_instances, __privateGet(_c, _Foo_instances, prop_get) * 1, prop_set);
|
|
__privateSet(_d = fn(), _Foo_instances, __privateGet(_d, _Foo_instances, prop_get) / 1, prop_set);
|
|
__privateSet(_e = fn(), _Foo_instances, __privateGet(_e, _Foo_instances, prop_get) % 1, prop_set);
|
|
__privateSet(_f = fn(), _Foo_instances, __privateGet(_f, _Foo_instances, prop_get) ** 1, prop_set);
|
|
__privateSet(_g = fn(), _Foo_instances, __privateGet(_g, _Foo_instances, prop_get) << 1, prop_set);
|
|
__privateSet(_h = fn(), _Foo_instances, __privateGet(_h, _Foo_instances, prop_get) >> 1, prop_set);
|
|
__privateSet(_i = fn(), _Foo_instances, __privateGet(_i, _Foo_instances, prop_get) >>> 1, prop_set);
|
|
__privateSet(_j = fn(), _Foo_instances, __privateGet(_j, _Foo_instances, prop_get) & 1, prop_set);
|
|
__privateSet(_k = fn(), _Foo_instances, __privateGet(_k, _Foo_instances, prop_get) | 1, prop_set);
|
|
__privateSet(_l = fn(), _Foo_instances, __privateGet(_l, _Foo_instances, prop_get) ^ 1, prop_set);
|
|
__privateGet(_m = fn(), _Foo_instances, prop_get) && __privateSet(_m, _Foo_instances, 1, prop_set);
|
|
__privateGet(_n = fn(), _Foo_instances, prop_get) || __privateSet(_n, _Foo_instances, 1, prop_set);
|
|
__privateGet(_o = fn(), _Foo_instances, prop_get) ?? __privateSet(_o, _Foo_instances, 1, prop_set);
|
|
}
|
|
};
|
|
_Foo_instances = new WeakSet();
|
|
foo_get = function() {
|
|
return this.foo;
|
|
};
|
|
bar_set = function(val) {
|
|
this.bar = val;
|
|
};
|
|
prop_get = function() {
|
|
return this.prop;
|
|
};
|
|
prop_set = function(val) {
|
|
this.prop = val;
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateGetterSetterNext
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var Foo = class {
|
|
get #foo() {
|
|
return this.foo;
|
|
}
|
|
set #bar(val) {
|
|
this.bar = val;
|
|
}
|
|
get #prop() {
|
|
return this.prop;
|
|
}
|
|
set #prop(val) {
|
|
this.prop = val;
|
|
}
|
|
foo(fn) {
|
|
fn().#foo;
|
|
fn().#bar = 1;
|
|
fn().#prop;
|
|
fn().#prop = 2;
|
|
}
|
|
unary(fn) {
|
|
fn().#prop++;
|
|
fn().#prop--;
|
|
++fn().#prop;
|
|
--fn().#prop;
|
|
}
|
|
binary(fn) {
|
|
fn().#prop = 1;
|
|
fn().#prop += 1;
|
|
fn().#prop -= 1;
|
|
fn().#prop *= 1;
|
|
fn().#prop /= 1;
|
|
fn().#prop %= 1;
|
|
fn().#prop **= 1;
|
|
fn().#prop <<= 1;
|
|
fn().#prop >>= 1;
|
|
fn().#prop >>>= 1;
|
|
fn().#prop &= 1;
|
|
fn().#prop |= 1;
|
|
fn().#prop ^= 1;
|
|
fn().#prop &&= 1;
|
|
fn().#prop ||= 1;
|
|
fn().#prop ??= 1;
|
|
}
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateMethod2019
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _field, _Foo_instances, method_fn;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _field);
|
|
}
|
|
baseline() {
|
|
var _a, _b, _c, _d, _e;
|
|
a().foo;
|
|
b().foo(x);
|
|
(_a = c()) == null ? void 0 : _a.foo(x);
|
|
(_c = (_b = d()).foo) == null ? void 0 : _c.call(_b, x);
|
|
(_e = (_d = e()) == null ? void 0 : _d.foo) == null ? void 0 : _e.call(_d, x);
|
|
}
|
|
privateField() {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h;
|
|
__privateGet(a(), _field);
|
|
__privateGet(_a = b(), _field).call(_a, x);
|
|
(_b = c()) == null ? void 0 : __privateGet(_b, _field).call(_b, x);
|
|
(_d = __privateGet(_c = d(), _field)) == null ? void 0 : _d.call(_c, x);
|
|
(_f = (_e = e()) == null ? void 0 : __privateGet(_e, _field)) == null ? void 0 : _f.call(_e, x);
|
|
(_g = f()) == null ? void 0 : __privateGet(_h = _g.foo, _field).call(_h, x).bar();
|
|
}
|
|
privateMethod() {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h;
|
|
__privateMethod(a(), _Foo_instances, method_fn);
|
|
__privateMethod(_a = b(), _Foo_instances, method_fn).call(_a, x);
|
|
(_b = c()) == null ? void 0 : __privateMethod(_b, _Foo_instances, method_fn).call(_b, x);
|
|
(_d = __privateMethod(_c = d(), _Foo_instances, method_fn)) == null ? void 0 : _d.call(_c, x);
|
|
(_f = (_e = e()) == null ? void 0 : __privateMethod(_e, _Foo_instances, method_fn)) == null ? void 0 : _f.call(_e, x);
|
|
(_g = f()) == null ? void 0 : __privateMethod(_h = _g.foo, _Foo_instances, method_fn).call(_h, x).bar();
|
|
}
|
|
};
|
|
_field = new WeakMap();
|
|
_Foo_instances = new WeakSet();
|
|
method_fn = function() {
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateMethod2020
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _field, _Foo_instances, method_fn;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
__privateAdd(this, _field);
|
|
}
|
|
baseline() {
|
|
a().foo;
|
|
b().foo(x);
|
|
c()?.foo(x);
|
|
d().foo?.(x);
|
|
e()?.foo?.(x);
|
|
}
|
|
privateField() {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
__privateGet(a(), _field);
|
|
__privateGet(_a = b(), _field).call(_a, x);
|
|
(_b = c()) == null ? void 0 : __privateGet(_b, _field).call(_b, x);
|
|
(_d = __privateGet(_c = d(), _field)) == null ? void 0 : _d.call(_c, x);
|
|
((_e = e()) == null ? void 0 : __privateGet(_e, _field))?.(x);
|
|
(_f = f()) == null ? void 0 : __privateGet(_g = _f.foo, _field).call(_g, x).bar();
|
|
}
|
|
privateMethod() {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
__privateMethod(a(), _Foo_instances, method_fn);
|
|
__privateMethod(_a = b(), _Foo_instances, method_fn).call(_a, x);
|
|
(_b = c()) == null ? void 0 : __privateMethod(_b, _Foo_instances, method_fn).call(_b, x);
|
|
(_d = __privateMethod(_c = d(), _Foo_instances, method_fn)) == null ? void 0 : _d.call(_c, x);
|
|
((_e = e()) == null ? void 0 : __privateMethod(_e, _Foo_instances, method_fn))?.(x);
|
|
(_f = f()) == null ? void 0 : __privateMethod(_g = _f.foo, _Foo_instances, method_fn).call(_g, x).bar();
|
|
}
|
|
};
|
|
_field = new WeakMap();
|
|
_Foo_instances = new WeakSet();
|
|
method_fn = function() {
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateMethodNext
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var Foo = class {
|
|
#field;
|
|
#method() {
|
|
}
|
|
baseline() {
|
|
a().foo;
|
|
b().foo(x);
|
|
c()?.foo(x);
|
|
d().foo?.(x);
|
|
e()?.foo?.(x);
|
|
}
|
|
privateField() {
|
|
a().#field;
|
|
b().#field(x);
|
|
c()?.#field(x);
|
|
d().#field?.(x);
|
|
e()?.#field?.(x);
|
|
f()?.foo.#field(x).bar();
|
|
}
|
|
privateMethod() {
|
|
a().#method;
|
|
b().#method(x);
|
|
c()?.#method(x);
|
|
d().#method?.(x);
|
|
e()?.#method?.(x);
|
|
f()?.foo.#method(x).bar();
|
|
}
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateMethodWithModifiers2020
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _Foo_instances, g_fn, a_fn, ag_fn, _Foo_static, sg_fn, sa_fn, sag_fn;
|
|
var Foo = class {
|
|
constructor() {
|
|
__privateAdd(this, _Foo_instances);
|
|
}
|
|
};
|
|
_Foo_instances = new WeakSet();
|
|
g_fn = function* () {
|
|
};
|
|
a_fn = async function() {
|
|
};
|
|
ag_fn = async function* () {
|
|
};
|
|
_Foo_static = new WeakSet();
|
|
sg_fn = function* () {
|
|
};
|
|
sa_fn = async function() {
|
|
};
|
|
sag_fn = async function* () {
|
|
};
|
|
__privateAdd(Foo, _Foo_static);
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateSuperES2021
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var _default_instances, foo_fn;
|
|
var _foo1_default = class _foo1_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _default_instances);
|
|
}
|
|
};
|
|
_default_instances = new WeakSet();
|
|
foo_fn = function() {
|
|
__superGet(_foo1_default.prototype, this, "foo").call(this);
|
|
};
|
|
var foo1_default = _foo1_default;
|
|
|
|
// foo2.js
|
|
var _default_instances2, foo_fn2;
|
|
var _foo2_default = class _foo2_default extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _default_instances2);
|
|
}
|
|
};
|
|
_default_instances2 = new WeakSet();
|
|
foo_fn2 = function() {
|
|
__superWrapper(_foo2_default.prototype, this, "foo")._++;
|
|
};
|
|
var foo2_default = _foo2_default;
|
|
|
|
// foo3.js
|
|
var _default_static, foo_fn3;
|
|
var _foo3_default = class _foo3_default extends x {
|
|
};
|
|
_default_static = new WeakSet();
|
|
foo_fn3 = function() {
|
|
__superGet(_foo3_default, this, "foo").call(this);
|
|
};
|
|
__privateAdd(_foo3_default, _default_static);
|
|
var foo3_default = _foo3_default;
|
|
|
|
// foo4.js
|
|
var _default_static2, foo_fn4;
|
|
var _foo4_default = class _foo4_default extends x {
|
|
};
|
|
_default_static2 = new WeakSet();
|
|
foo_fn4 = function() {
|
|
__superWrapper(_foo4_default, this, "foo")._++;
|
|
};
|
|
__privateAdd(_foo4_default, _default_static2);
|
|
var foo4_default = _foo4_default;
|
|
|
|
// foo5.js
|
|
var _foo;
|
|
var foo5_default = class extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _foo, () => {
|
|
super.foo();
|
|
});
|
|
}
|
|
};
|
|
_foo = new WeakMap();
|
|
|
|
// foo6.js
|
|
var _foo2;
|
|
var foo6_default = class extends x {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _foo2, () => {
|
|
super.foo++;
|
|
});
|
|
}
|
|
};
|
|
_foo2 = new WeakMap();
|
|
|
|
// foo7.js
|
|
var _foo3;
|
|
var _foo7_default = class _foo7_default extends x {
|
|
};
|
|
_foo3 = new WeakMap();
|
|
__privateAdd(_foo7_default, _foo3, () => {
|
|
__superGet(_foo7_default, _foo7_default, "foo").call(this);
|
|
});
|
|
var foo7_default = _foo7_default;
|
|
|
|
// foo8.js
|
|
var _foo4;
|
|
var _foo8_default = class _foo8_default extends x {
|
|
};
|
|
_foo4 = new WeakMap();
|
|
__privateAdd(_foo8_default, _foo4, () => {
|
|
__superWrapper(_foo8_default, _foo8_default, "foo")._++;
|
|
});
|
|
var foo8_default = _foo8_default;
|
|
export {
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4,
|
|
foo5_default as foo5,
|
|
foo6_default as foo6,
|
|
foo7_default as foo7,
|
|
foo8_default as foo8
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateSuperES2022
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var foo1_default = class extends x {
|
|
#foo() {
|
|
super.foo();
|
|
}
|
|
};
|
|
|
|
// foo2.js
|
|
var foo2_default = class extends x {
|
|
#foo() {
|
|
super.foo++;
|
|
}
|
|
};
|
|
|
|
// foo3.js
|
|
var foo3_default = class extends x {
|
|
static #foo() {
|
|
super.foo();
|
|
}
|
|
};
|
|
|
|
// foo4.js
|
|
var foo4_default = class extends x {
|
|
static #foo() {
|
|
super.foo++;
|
|
}
|
|
};
|
|
|
|
// foo5.js
|
|
var foo5_default = class extends x {
|
|
#foo = () => {
|
|
super.foo();
|
|
};
|
|
};
|
|
|
|
// foo6.js
|
|
var foo6_default = class extends x {
|
|
#foo = () => {
|
|
super.foo++;
|
|
};
|
|
};
|
|
|
|
// foo7.js
|
|
var foo7_default = class extends x {
|
|
static #foo = () => {
|
|
super.foo();
|
|
};
|
|
};
|
|
|
|
// foo8.js
|
|
var foo8_default = class extends x {
|
|
static #foo = () => {
|
|
super.foo++;
|
|
};
|
|
};
|
|
export {
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4,
|
|
foo5_default as foo5,
|
|
foo6_default as foo6,
|
|
foo7_default as foo7,
|
|
foo8_default as foo8
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerPrivateSuperStaticBundleIssue2158
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var Foo = class extends Object {
|
|
static FOO;
|
|
constructor() {
|
|
super();
|
|
}
|
|
#foo;
|
|
};
|
|
export {
|
|
Foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerRegExpNameCollision
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
function foo(RegExp2) {
|
|
return new RegExp2(new RegExp(".", "d"), "d");
|
|
}
|
|
export {
|
|
foo
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerStaticAsyncArrowSuperES2016
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var foo1_default = class _foo1_default extends x {
|
|
static foo1() {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_foo1_default, this, "foo").call(this, "foo1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo2.js
|
|
var foo2_default = class _foo2_default extends x {
|
|
static foo2() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __superGet(_foo2_default, this, "foo").call(this, "foo2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo3.js
|
|
var foo3_default = class _foo3_default extends x {
|
|
static foo3() {
|
|
return () => () => __async(null, null, function* () {
|
|
return __superGet(_foo3_default, this, "foo").call(this, "foo3");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo4.js
|
|
var foo4_default = class _foo4_default extends x {
|
|
static foo4() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_foo4_default, this, "foo").call(this, "foo4");
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// bar1.js
|
|
var _bar1_default = class _bar1_default extends x {
|
|
};
|
|
__publicField(_bar1_default, "bar1", () => __async(null, null, function* () {
|
|
return __superGet(_bar1_default, _bar1_default, "foo").call(this, "bar1");
|
|
}));
|
|
var bar1_default = _bar1_default;
|
|
|
|
// bar2.js
|
|
var _bar2_default = class _bar2_default extends x {
|
|
};
|
|
__publicField(_bar2_default, "bar2", () => __async(null, null, function* () {
|
|
return () => __superGet(_bar2_default, _bar2_default, "foo").call(this, "bar2");
|
|
}));
|
|
var bar2_default = _bar2_default;
|
|
|
|
// bar3.js
|
|
var _bar3_default = class _bar3_default extends x {
|
|
};
|
|
__publicField(_bar3_default, "bar3", () => () => __async(null, null, function* () {
|
|
return __superGet(_bar3_default, _bar3_default, "foo").call(this, "bar3");
|
|
}));
|
|
var bar3_default = _bar3_default;
|
|
|
|
// bar4.js
|
|
var _bar4_default = class _bar4_default extends x {
|
|
};
|
|
__publicField(_bar4_default, "bar4", () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superGet(_bar4_default, _bar4_default, "foo").call(this, "bar4");
|
|
});
|
|
}));
|
|
var bar4_default = _bar4_default;
|
|
|
|
// baz1.js
|
|
var baz1_default = class _baz1_default extends x {
|
|
static baz1() {
|
|
return __async(this, null, function* () {
|
|
return () => __superGet(_baz1_default, this, "foo").call(this, "baz1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// baz2.js
|
|
var baz2_default = class _baz2_default extends x {
|
|
static baz2() {
|
|
return __async(this, null, function* () {
|
|
return () => () => __superGet(_baz2_default, this, "foo").call(this, "baz2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// outer.js
|
|
var outer_default = (function() {
|
|
return __async(this, null, function* () {
|
|
const _y = class _y extends z {
|
|
};
|
|
__publicField(_y, "foo", () => __async(null, null, function* () {
|
|
return __superGet(_y, _y, "foo").call(this);
|
|
}));
|
|
let y = _y;
|
|
yield y.foo()();
|
|
});
|
|
})();
|
|
export {
|
|
bar1_default as bar1,
|
|
bar2_default as bar2,
|
|
bar3_default as bar3,
|
|
bar4_default as bar4,
|
|
baz1_default as baz1,
|
|
baz2_default as baz2,
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerStaticAsyncArrowSuperSetterES2016
|
|
---------- /out.js ----------
|
|
// foo1.js
|
|
var foo1_default = class _foo1_default extends x {
|
|
static foo1() {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_foo1_default, this, "foo", "foo1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo2.js
|
|
var foo2_default = class _foo2_default extends x {
|
|
static foo2() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __superSet(_foo2_default, this, "foo", "foo2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo3.js
|
|
var foo3_default = class _foo3_default extends x {
|
|
static foo3() {
|
|
return () => () => __async(null, null, function* () {
|
|
return __superSet(_foo3_default, this, "foo", "foo3");
|
|
});
|
|
}
|
|
};
|
|
|
|
// foo4.js
|
|
var foo4_default = class _foo4_default extends x {
|
|
static foo4() {
|
|
return () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_foo4_default, this, "foo", "foo4");
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// bar1.js
|
|
var _bar1_default = class _bar1_default extends x {
|
|
};
|
|
__publicField(_bar1_default, "bar1", () => __async(null, null, function* () {
|
|
return __superSet(_bar1_default, _bar1_default, "foo", "bar1");
|
|
}));
|
|
var bar1_default = _bar1_default;
|
|
|
|
// bar2.js
|
|
var _bar2_default = class _bar2_default extends x {
|
|
};
|
|
__publicField(_bar2_default, "bar2", () => __async(null, null, function* () {
|
|
return () => __superSet(_bar2_default, _bar2_default, "foo", "bar2");
|
|
}));
|
|
var bar2_default = _bar2_default;
|
|
|
|
// bar3.js
|
|
var _bar3_default = class _bar3_default extends x {
|
|
};
|
|
__publicField(_bar3_default, "bar3", () => () => __async(null, null, function* () {
|
|
return __superSet(_bar3_default, _bar3_default, "foo", "bar3");
|
|
}));
|
|
var bar3_default = _bar3_default;
|
|
|
|
// bar4.js
|
|
var _bar4_default = class _bar4_default extends x {
|
|
};
|
|
__publicField(_bar4_default, "bar4", () => __async(null, null, function* () {
|
|
return () => __async(null, null, function* () {
|
|
return __superSet(_bar4_default, _bar4_default, "foo", "bar4");
|
|
});
|
|
}));
|
|
var bar4_default = _bar4_default;
|
|
|
|
// baz1.js
|
|
var baz1_default = class _baz1_default extends x {
|
|
static baz1() {
|
|
return __async(this, null, function* () {
|
|
return () => __superSet(_baz1_default, this, "foo", "baz1");
|
|
});
|
|
}
|
|
};
|
|
|
|
// baz2.js
|
|
var baz2_default = class _baz2_default extends x {
|
|
static baz2() {
|
|
return __async(this, null, function* () {
|
|
return () => () => __superSet(_baz2_default, this, "foo", "baz2");
|
|
});
|
|
}
|
|
};
|
|
|
|
// outer.js
|
|
var outer_default = (function() {
|
|
return __async(this, null, function* () {
|
|
const _y = class _y extends z {
|
|
};
|
|
__publicField(_y, "foo", () => __async(null, null, function* () {
|
|
return __superSet(_y, _y, "foo", "foo");
|
|
}));
|
|
let y = _y;
|
|
yield y.foo()();
|
|
});
|
|
})();
|
|
export {
|
|
bar1_default as bar1,
|
|
bar2_default as bar2,
|
|
bar3_default as bar3,
|
|
bar4_default as bar4,
|
|
baz1_default as baz1,
|
|
baz2_default as baz2,
|
|
foo1_default as foo1,
|
|
foo2_default as foo2,
|
|
foo3_default as foo3,
|
|
foo4_default as foo4
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerStaticAsyncSuperES2016NoBundle
|
|
---------- /out.js ----------
|
|
const _Derived = class _Derived extends Base {
|
|
};
|
|
__publicField(_Derived, "test", (key) => __async(null, null, function* () {
|
|
var _a, _b, _c, _d;
|
|
return [
|
|
yield __superGet(_Derived, _Derived, "foo"),
|
|
yield __superGet(_Derived, _Derived, key),
|
|
yield [__superWrapper(_Derived, _Derived, "foo")._] = [0],
|
|
yield [__superWrapper(_Derived, _Derived, key)._] = [0],
|
|
yield __superSet(_Derived, _Derived, "foo", 1),
|
|
yield __superSet(_Derived, _Derived, key, 1),
|
|
yield __superSet(_Derived, _Derived, "foo", __superGet(_Derived, _Derived, "foo") + 2),
|
|
yield __superSet(_Derived, _Derived, key, __superGet(_Derived, _Derived, key) + 2),
|
|
yield ++__superWrapper(_Derived, _Derived, "foo")._,
|
|
yield ++__superWrapper(_Derived, _Derived, key)._,
|
|
yield __superWrapper(_Derived, _Derived, "foo")._++,
|
|
yield __superWrapper(_Derived, _Derived, key)._++,
|
|
yield __superGet(_Derived, _Derived, "foo").name,
|
|
yield __superGet(_Derived, _Derived, key).name,
|
|
yield (_a = __superGet(_Derived, _Derived, "foo")) == null ? void 0 : _a.name,
|
|
yield (_b = __superGet(_Derived, _Derived, key)) == null ? void 0 : _b.name,
|
|
yield __superGet(_Derived, _Derived, "foo").call(this, 1, 2),
|
|
yield __superGet(_Derived, _Derived, key).call(this, 1, 2),
|
|
yield (_c = __superGet(_Derived, _Derived, "foo")) == null ? void 0 : _c.call(this, 1, 2),
|
|
yield (_d = __superGet(_Derived, _Derived, key)) == null ? void 0 : _d.call(this, 1, 2),
|
|
yield (() => __superGet(_Derived, _Derived, "foo"))(),
|
|
yield (() => __superGet(_Derived, _Derived, key))(),
|
|
yield (() => __superGet(_Derived, _Derived, "foo").call(this))(),
|
|
yield (() => __superGet(_Derived, _Derived, key).call(this))(),
|
|
yield __superGet(_Derived, _Derived, "foo").bind(this)``,
|
|
yield __superGet(_Derived, _Derived, key).bind(this)``
|
|
];
|
|
}));
|
|
let Derived = _Derived;
|
|
let fn = () => __async(null, null, function* () {
|
|
var _a;
|
|
return _a = class extends Base {
|
|
static c() {
|
|
return super.c;
|
|
}
|
|
static d() {
|
|
return () => super.d;
|
|
}
|
|
}, __publicField(_a, "a", __superGet(_a, _a, "a")), __publicField(_a, "b", () => __superGet(_a, _a, "b")), _a;
|
|
});
|
|
const _Derived2 = class _Derived2 extends Base {
|
|
static a() {
|
|
return __async(this, null, function* () {
|
|
var _a;
|
|
return _a = __superGet(_Derived2, this, "foo"), class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
};
|
|
__publicField(_Derived2, "b", () => __async(null, null, function* () {
|
|
var _a;
|
|
return _a = __superGet(_Derived2, _Derived2, "foo"), class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
}));
|
|
let Derived2 = _Derived2;
|
|
|
|
================================================================================
|
|
TestLowerStaticAsyncSuperES2021NoBundle
|
|
---------- /out.js ----------
|
|
const _Derived = class _Derived extends Base {
|
|
};
|
|
__publicField(_Derived, "test", async (key) => {
|
|
return [
|
|
await __superGet(_Derived, _Derived, "foo"),
|
|
await __superGet(_Derived, _Derived, key),
|
|
await ([__superWrapper(_Derived, _Derived, "foo")._] = [0]),
|
|
await ([__superWrapper(_Derived, _Derived, key)._] = [0]),
|
|
await __superSet(_Derived, _Derived, "foo", 1),
|
|
await __superSet(_Derived, _Derived, key, 1),
|
|
await __superSet(_Derived, _Derived, "foo", __superGet(_Derived, _Derived, "foo") + 2),
|
|
await __superSet(_Derived, _Derived, key, __superGet(_Derived, _Derived, key) + 2),
|
|
await ++__superWrapper(_Derived, _Derived, "foo")._,
|
|
await ++__superWrapper(_Derived, _Derived, key)._,
|
|
await __superWrapper(_Derived, _Derived, "foo")._++,
|
|
await __superWrapper(_Derived, _Derived, key)._++,
|
|
await __superGet(_Derived, _Derived, "foo").name,
|
|
await __superGet(_Derived, _Derived, key).name,
|
|
await __superGet(_Derived, _Derived, "foo")?.name,
|
|
await __superGet(_Derived, _Derived, key)?.name,
|
|
await __superGet(_Derived, _Derived, "foo").call(this, 1, 2),
|
|
await __superGet(_Derived, _Derived, key).call(this, 1, 2),
|
|
await super.foo?.(1, 2),
|
|
await super[key]?.(1, 2),
|
|
await (() => __superGet(_Derived, _Derived, "foo"))(),
|
|
await (() => __superGet(_Derived, _Derived, key))(),
|
|
await (() => __superGet(_Derived, _Derived, "foo").call(this))(),
|
|
await (() => __superGet(_Derived, _Derived, key).call(this))(),
|
|
await __superGet(_Derived, _Derived, "foo").bind(this)``,
|
|
await __superGet(_Derived, _Derived, key).bind(this)``
|
|
];
|
|
});
|
|
let Derived = _Derived;
|
|
let fn = async () => {
|
|
var _a;
|
|
return _a = class extends Base {
|
|
static c() {
|
|
return super.c;
|
|
}
|
|
static d() {
|
|
return () => super.d;
|
|
}
|
|
}, __publicField(_a, "a", __superGet(_a, _a, "a")), __publicField(_a, "b", () => __superGet(_a, _a, "b")), _a;
|
|
};
|
|
const _Derived2 = class _Derived2 extends Base {
|
|
static async a() {
|
|
var _a;
|
|
return _a = super.foo, class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
__publicField(_Derived2, "b", async () => {
|
|
var _a;
|
|
return _a = __superGet(_Derived2, _Derived2, "foo"), class {
|
|
constructor() {
|
|
__publicField(this, _a, 123);
|
|
}
|
|
};
|
|
});
|
|
let Derived2 = _Derived2;
|
|
|
|
================================================================================
|
|
TestLowerStaticSuperES2016NoBundle
|
|
---------- /out.js ----------
|
|
const _Derived = class _Derived extends Base {
|
|
};
|
|
__publicField(_Derived, "test", (key) => {
|
|
var _a, _b, _c, _d;
|
|
return [
|
|
__superGet(_Derived, _Derived, "foo"),
|
|
__superGet(_Derived, _Derived, key),
|
|
[__superWrapper(_Derived, _Derived, "foo")._] = [0],
|
|
[__superWrapper(_Derived, _Derived, key)._] = [0],
|
|
__superSet(_Derived, _Derived, "foo", 1),
|
|
__superSet(_Derived, _Derived, key, 1),
|
|
__superSet(_Derived, _Derived, "foo", __superGet(_Derived, _Derived, "foo") + 2),
|
|
__superSet(_Derived, _Derived, key, __superGet(_Derived, _Derived, key) + 2),
|
|
++__superWrapper(_Derived, _Derived, "foo")._,
|
|
++__superWrapper(_Derived, _Derived, key)._,
|
|
__superWrapper(_Derived, _Derived, "foo")._++,
|
|
__superWrapper(_Derived, _Derived, key)._++,
|
|
__superGet(_Derived, _Derived, "foo").name,
|
|
__superGet(_Derived, _Derived, key).name,
|
|
(_a = __superGet(_Derived, _Derived, "foo")) == null ? void 0 : _a.name,
|
|
(_b = __superGet(_Derived, _Derived, key)) == null ? void 0 : _b.name,
|
|
__superGet(_Derived, _Derived, "foo").call(this, 1, 2),
|
|
__superGet(_Derived, _Derived, key).call(this, 1, 2),
|
|
(_c = __superGet(_Derived, _Derived, "foo")) == null ? void 0 : _c.call(this, 1, 2),
|
|
(_d = __superGet(_Derived, _Derived, key)) == null ? void 0 : _d.call(this, 1, 2),
|
|
(() => __superGet(_Derived, _Derived, "foo"))(),
|
|
(() => __superGet(_Derived, _Derived, key))(),
|
|
(() => __superGet(_Derived, _Derived, "foo").call(this))(),
|
|
(() => __superGet(_Derived, _Derived, key).call(this))(),
|
|
__superGet(_Derived, _Derived, "foo").bind(this)``,
|
|
__superGet(_Derived, _Derived, key).bind(this)``
|
|
];
|
|
});
|
|
let Derived = _Derived;
|
|
|
|
================================================================================
|
|
TestLowerStaticSuperES2021NoBundle
|
|
---------- /out.js ----------
|
|
const _Derived = class _Derived extends Base {
|
|
};
|
|
__publicField(_Derived, "test", (key) => {
|
|
return [
|
|
__superGet(_Derived, _Derived, "foo"),
|
|
__superGet(_Derived, _Derived, key),
|
|
[__superWrapper(_Derived, _Derived, "foo")._] = [0],
|
|
[__superWrapper(_Derived, _Derived, key)._] = [0],
|
|
__superSet(_Derived, _Derived, "foo", 1),
|
|
__superSet(_Derived, _Derived, key, 1),
|
|
__superSet(_Derived, _Derived, "foo", __superGet(_Derived, _Derived, "foo") + 2),
|
|
__superSet(_Derived, _Derived, key, __superGet(_Derived, _Derived, key) + 2),
|
|
++__superWrapper(_Derived, _Derived, "foo")._,
|
|
++__superWrapper(_Derived, _Derived, key)._,
|
|
__superWrapper(_Derived, _Derived, "foo")._++,
|
|
__superWrapper(_Derived, _Derived, key)._++,
|
|
__superGet(_Derived, _Derived, "foo").name,
|
|
__superGet(_Derived, _Derived, key).name,
|
|
__superGet(_Derived, _Derived, "foo")?.name,
|
|
__superGet(_Derived, _Derived, key)?.name,
|
|
__superGet(_Derived, _Derived, "foo").call(this, 1, 2),
|
|
__superGet(_Derived, _Derived, key).call(this, 1, 2),
|
|
super.foo?.(1, 2),
|
|
super[key]?.(1, 2),
|
|
(() => __superGet(_Derived, _Derived, "foo"))(),
|
|
(() => __superGet(_Derived, _Derived, key))(),
|
|
(() => __superGet(_Derived, _Derived, "foo").call(this))(),
|
|
(() => __superGet(_Derived, _Derived, key).call(this))(),
|
|
__superGet(_Derived, _Derived, "foo").bind(this)``,
|
|
__superGet(_Derived, _Derived, key).bind(this)``
|
|
];
|
|
});
|
|
let Derived = _Derived;
|
|
|
|
================================================================================
|
|
TestLowerStrictModeSyntax
|
|
---------- /out.js ----------
|
|
// for-in.js
|
|
if (test) {
|
|
a = b;
|
|
for (a in {}) ;
|
|
}
|
|
var a;
|
|
x = y;
|
|
for (x in {}) ;
|
|
var x;
|
|
|
|
================================================================================
|
|
TestLowerTemplateObject
|
|
---------- /out.js ----------
|
|
var _a, _b, _c, _d, _e, _f, _g, _h;
|
|
x = () => [
|
|
tag(_a || (_a = __template(["x"]))),
|
|
tag(_b || (_b = __template(["ÿ"], ["\\xFF"]))),
|
|
tag(_c || (_c = __template([void 0], ["\\x"]))),
|
|
tag(_d || (_d = __template([void 0], ["\\u"])))
|
|
];
|
|
y = () => [
|
|
tag(_e || (_e = __template(["x", "z"])), y),
|
|
tag(_f || (_f = __template(["ÿ", "z"], ["\\xFF", "z"])), y),
|
|
tag(_g || (_g = __template(["x", "z"], ["x", "\\z"])), y),
|
|
tag(_h || (_h = __template(["x", void 0], ["x", "\\u"])), y)
|
|
];
|
|
|
|
================================================================================
|
|
TestLowerUsing
|
|
---------- /out/entry.js ----------
|
|
function foo() {
|
|
var _stack4 = [];
|
|
try {
|
|
const a2 = __using(_stack4, b);
|
|
if (nested) {
|
|
var _stack3 = [];
|
|
try {
|
|
const x = __using(_stack3, 1);
|
|
} catch (_3) {
|
|
var _error3 = _3, _hasError3 = true;
|
|
} finally {
|
|
__callDispose(_stack3, _error3, _hasError3);
|
|
}
|
|
}
|
|
} catch (_4) {
|
|
var _error4 = _4, _hasError4 = true;
|
|
} finally {
|
|
__callDispose(_stack4, _error4, _hasError4);
|
|
}
|
|
}
|
|
async function bar() {
|
|
var _stack4 = [];
|
|
try {
|
|
const a2 = __using(_stack4, b);
|
|
const c2 = __using(_stack4, d, true);
|
|
if (nested) {
|
|
var _stack3 = [];
|
|
try {
|
|
const x = __using(_stack3, 1);
|
|
const y = __using(_stack3, 2, true);
|
|
} catch (_3) {
|
|
var _error3 = _3, _hasError3 = true;
|
|
} finally {
|
|
var _promise3 = __callDispose(_stack3, _error3, _hasError3);
|
|
_promise3 && await _promise3;
|
|
}
|
|
}
|
|
} catch (_4) {
|
|
var _error4 = _4, _hasError4 = true;
|
|
} finally {
|
|
var _promise4 = __callDispose(_stack4, _error4, _hasError4);
|
|
_promise4 && await _promise4;
|
|
}
|
|
}
|
|
var _stack2 = [];
|
|
try {
|
|
var a = __using(_stack2, b);
|
|
var c = __using(_stack2, d, true);
|
|
if (nested) {
|
|
var _stack = [];
|
|
try {
|
|
const x = __using(_stack, 1);
|
|
const y = __using(_stack, 2, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && await _promise;
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && await _promise2;
|
|
}
|
|
|
|
---------- /out/loops.js ----------
|
|
for (var _a of b) {
|
|
var _stack = [];
|
|
try {
|
|
const a = __using(_stack, _a);
|
|
c(() => a);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
}
|
|
for (var _d of e) {
|
|
var _stack2 = [];
|
|
try {
|
|
const d = __using(_stack2, _d, true);
|
|
f(() => d);
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise && await _promise;
|
|
}
|
|
}
|
|
for await (var _g of h) {
|
|
var _stack3 = [];
|
|
try {
|
|
const g = __using(_stack3, _g);
|
|
i(() => g);
|
|
} catch (_3) {
|
|
var _error3 = _3, _hasError3 = true;
|
|
} finally {
|
|
__callDispose(_stack3, _error3, _hasError3);
|
|
}
|
|
}
|
|
for await (var _j of k) {
|
|
var _stack4 = [];
|
|
try {
|
|
const j = __using(_stack4, _j, true);
|
|
l(() => j);
|
|
} catch (_4) {
|
|
var _error4 = _4, _hasError4 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack4, _error4, _hasError4);
|
|
_promise2 && await _promise2;
|
|
}
|
|
}
|
|
if (nested) {
|
|
for (var _a of b) {
|
|
var _stack5 = [];
|
|
try {
|
|
const a = __using(_stack5, _a);
|
|
c(() => a);
|
|
} catch (_5) {
|
|
var _error5 = _5, _hasError5 = true;
|
|
} finally {
|
|
__callDispose(_stack5, _error5, _hasError5);
|
|
}
|
|
}
|
|
for (var _d of e) {
|
|
var _stack6 = [];
|
|
try {
|
|
const d = __using(_stack6, _d, true);
|
|
f(() => d);
|
|
} catch (_6) {
|
|
var _error6 = _6, _hasError6 = true;
|
|
} finally {
|
|
var _promise3 = __callDispose(_stack6, _error6, _hasError6);
|
|
_promise3 && await _promise3;
|
|
}
|
|
}
|
|
for await (var _g of h) {
|
|
var _stack7 = [];
|
|
try {
|
|
const g = __using(_stack7, _g);
|
|
i(() => g);
|
|
} catch (_7) {
|
|
var _error7 = _7, _hasError7 = true;
|
|
} finally {
|
|
__callDispose(_stack7, _error7, _hasError7);
|
|
}
|
|
}
|
|
for await (var _j of k) {
|
|
var _stack8 = [];
|
|
try {
|
|
const j = __using(_stack8, _j, true);
|
|
l(() => j);
|
|
} catch (_8) {
|
|
var _error8 = _8, _hasError8 = true;
|
|
} finally {
|
|
var _promise4 = __callDispose(_stack8, _error8, _hasError8);
|
|
_promise4 && await _promise4;
|
|
}
|
|
}
|
|
}
|
|
function foo() {
|
|
for (var _a of b) {
|
|
var _stack9 = [];
|
|
try {
|
|
const a = __using(_stack9, _a);
|
|
c(() => a);
|
|
} catch (_9) {
|
|
var _error9 = _9, _hasError9 = true;
|
|
} finally {
|
|
__callDispose(_stack9, _error9, _hasError9);
|
|
}
|
|
}
|
|
}
|
|
async function bar() {
|
|
for (var _a of b) {
|
|
var _stack9 = [];
|
|
try {
|
|
const a = __using(_stack9, _a);
|
|
c(() => a);
|
|
} catch (_9) {
|
|
var _error9 = _9, _hasError9 = true;
|
|
} finally {
|
|
__callDispose(_stack9, _error9, _hasError9);
|
|
}
|
|
}
|
|
for (var _d of e) {
|
|
var _stack10 = [];
|
|
try {
|
|
const d = __using(_stack10, _d, true);
|
|
f(() => d);
|
|
} catch (_10) {
|
|
var _error10 = _10, _hasError10 = true;
|
|
} finally {
|
|
var _promise5 = __callDispose(_stack10, _error10, _hasError10);
|
|
_promise5 && await _promise5;
|
|
}
|
|
}
|
|
for await (var _g of h) {
|
|
var _stack11 = [];
|
|
try {
|
|
const g = __using(_stack11, _g);
|
|
i(() => g);
|
|
} catch (_11) {
|
|
var _error11 = _11, _hasError11 = true;
|
|
} finally {
|
|
__callDispose(_stack11, _error11, _hasError11);
|
|
}
|
|
}
|
|
for await (var _j of k) {
|
|
var _stack12 = [];
|
|
try {
|
|
const j = __using(_stack12, _j, true);
|
|
l(() => j);
|
|
} catch (_12) {
|
|
var _error12 = _12, _hasError12 = true;
|
|
} finally {
|
|
var _promise6 = __callDispose(_stack12, _error12, _hasError12);
|
|
_promise6 && await _promise6;
|
|
}
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerUsingHoisting
|
|
---------- /out/hoist-use-strict.js ----------
|
|
"use strict";
|
|
function foo() {
|
|
"use strict";
|
|
var _stack2 = [];
|
|
try {
|
|
const a2 = __using(_stack2, b);
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
__callDispose(_stack2, _error2, _hasError2);
|
|
}
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-directive.js ----------
|
|
"use wtf";
|
|
function foo() {
|
|
"use wtf";
|
|
var _stack2 = [];
|
|
try {
|
|
const a2 = __using(_stack2, b);
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
__callDispose(_stack2, _error2, _hasError2);
|
|
}
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-import.js ----------
|
|
import "./foo";
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-star.js ----------
|
|
export * from "./foo";
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-from.js ----------
|
|
export { x, y } from "./foo";
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-clause.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
a,
|
|
c as "c!"
|
|
};
|
|
|
|
---------- /out/hoist-export-local-direct.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var ac1 = [a, c], { x: [x1] } = foo;
|
|
var a1 = a, { y: [y1] } = foo;
|
|
var c1 = c, { z: [z1] } = foo;
|
|
var ac2 = [a, c], { x: [x2] } = foo;
|
|
var a2 = a, { y: [y2] } = foo;
|
|
var c2 = c, { z: [z2] } = foo;
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
ac1,
|
|
x1,
|
|
a1,
|
|
y1,
|
|
c1,
|
|
z1
|
|
};
|
|
|
|
---------- /out/hoist-export-local-indirect.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var ac1 = [a, c], { x: [x1] } = foo;
|
|
var a1 = a, { y: [y1] } = foo;
|
|
var c1 = c, { z: [z1] } = foo;
|
|
var ac2 = [a, c], { x: [x2] } = foo;
|
|
var a2 = a, { y: [y2] } = foo;
|
|
var c2 = c, { z: [z2] } = foo;
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
x1,
|
|
y1,
|
|
z1
|
|
};
|
|
|
|
---------- /out/hoist-export-class-direct.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var Foo1 = class {
|
|
ac = [a, c];
|
|
};
|
|
var Bar1 = class _Bar1 {
|
|
ac = [a, c, _Bar1];
|
|
};
|
|
var Foo2 = class {
|
|
ac = [a, c];
|
|
};
|
|
var Bar2 = class _Bar2 {
|
|
ac = [a, c, _Bar2];
|
|
};
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
Foo1,
|
|
Bar1
|
|
};
|
|
|
|
---------- /out/hoist-export-class-indirect.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var Foo1 = class {
|
|
ac = [a, c];
|
|
};
|
|
var Bar1 = class _Bar1 {
|
|
ac = [a, c, _Bar1];
|
|
};
|
|
var Foo2 = class {
|
|
ac = [a, c];
|
|
};
|
|
var Bar2 = class _Bar2 {
|
|
ac = [a, c, _Bar2];
|
|
};
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
Foo1,
|
|
Bar1
|
|
};
|
|
|
|
---------- /out/hoist-export-function-direct.js ----------
|
|
export function foo1() {
|
|
return [a, c];
|
|
}
|
|
export function bar1() {
|
|
return [a, c, bar1];
|
|
}
|
|
function foo2() {
|
|
return [a, c];
|
|
}
|
|
function bar2() {
|
|
return [a, c, bar2];
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-function-indirect.js ----------
|
|
function foo1() {
|
|
return [a, c];
|
|
}
|
|
function bar1() {
|
|
return [a, c, bar1];
|
|
}
|
|
function foo2() {
|
|
return [a, c];
|
|
}
|
|
function bar2() {
|
|
return [a, c, bar2];
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
foo1,
|
|
bar1
|
|
};
|
|
|
|
---------- /out/hoist-export-default-class-name-unused.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var Foo = class {
|
|
ac = [a, c];
|
|
};
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
Foo as default
|
|
};
|
|
|
|
---------- /out/hoist-export-default-class-name-used.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var Foo = class _Foo {
|
|
ac = [a, c, _Foo];
|
|
};
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
Foo as default
|
|
};
|
|
|
|
---------- /out/hoist-export-default-class-anonymous.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var hoist_export_default_class_anonymous_default = class {
|
|
ac = [a, c];
|
|
};
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
hoist_export_default_class_anonymous_default as default
|
|
};
|
|
|
|
---------- /out/hoist-export-default-function-name-unused.js ----------
|
|
export default function foo() {
|
|
return [a, c];
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-default-function-name-used.js ----------
|
|
export default function foo() {
|
|
return [a, c, foo];
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-default-function-anonymous.js ----------
|
|
export default function() {
|
|
return [a, c];
|
|
}
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
|
|
---------- /out/hoist-export-default-expr.js ----------
|
|
var _stack = [];
|
|
try {
|
|
var a = __using(_stack, b);
|
|
var hoist_export_default_expr_default = [a, c];
|
|
var c = __using(_stack, d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
export {
|
|
hoist_export_default_expr_default as default
|
|
};
|
|
|
|
================================================================================
|
|
TestLowerUsingInsideTSNamespace
|
|
---------- /out/entry.js ----------
|
|
var ns;
|
|
((ns2) => {
|
|
var _stack = [];
|
|
try {
|
|
ns2.a = b;
|
|
const c = __using(_stack, d);
|
|
ns2.e = f;
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
})(ns || (ns = {}));
|
|
|
|
================================================================================
|
|
TestLowerUsingUnsupportedAsync
|
|
---------- /out/entry.js ----------
|
|
function foo() {
|
|
using a = b;
|
|
if (nested) {
|
|
using x = 1;
|
|
}
|
|
}
|
|
function bar() {
|
|
return __async(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
const a = __using(_stack2, b);
|
|
const c = __using(_stack2, d, true);
|
|
if (nested) {
|
|
var _stack = [];
|
|
try {
|
|
const x = __using(_stack, 1);
|
|
const y = __using(_stack, 2, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield _promise);
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield _promise2);
|
|
}
|
|
});
|
|
}
|
|
|
|
---------- /out/loops.js ----------
|
|
for (using a of b) c(() => a);
|
|
if (nested) {
|
|
for (using a of b) c(() => a);
|
|
}
|
|
function foo() {
|
|
for (using a of b) c(() => a);
|
|
}
|
|
function bar() {
|
|
return __async(this, null, function* () {
|
|
for (using a of b) c(() => a);
|
|
for (var _d of e) {
|
|
var _stack = [];
|
|
try {
|
|
const d = __using(_stack, _d, true);
|
|
f(() => d);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield _promise);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
================================================================================
|
|
TestLowerUsingUnsupportedUsingAndAsync
|
|
---------- /out/entry.js ----------
|
|
function foo() {
|
|
var _stack2 = [];
|
|
try {
|
|
const a = __using(_stack2, b);
|
|
if (nested) {
|
|
var _stack = [];
|
|
try {
|
|
const x = __using(_stack, 1);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
__callDispose(_stack2, _error2, _hasError2);
|
|
}
|
|
}
|
|
function bar() {
|
|
return __async(this, null, function* () {
|
|
var _stack2 = [];
|
|
try {
|
|
const a = __using(_stack2, b);
|
|
const c = __using(_stack2, d, true);
|
|
if (nested) {
|
|
var _stack = [];
|
|
try {
|
|
const x = __using(_stack, 1);
|
|
const y = __using(_stack, 2, true);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack, _error, _hasError);
|
|
_promise && (yield _promise);
|
|
}
|
|
}
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
var _promise2 = __callDispose(_stack2, _error2, _hasError2);
|
|
_promise2 && (yield _promise2);
|
|
}
|
|
});
|
|
}
|
|
|
|
---------- /out/loops.js ----------
|
|
for (var _a of b) {
|
|
var _stack = [];
|
|
try {
|
|
const a = __using(_stack, _a);
|
|
c(() => a);
|
|
} catch (_) {
|
|
var _error = _, _hasError = true;
|
|
} finally {
|
|
__callDispose(_stack, _error, _hasError);
|
|
}
|
|
}
|
|
if (nested) {
|
|
for (var _a of b) {
|
|
var _stack2 = [];
|
|
try {
|
|
const a = __using(_stack2, _a);
|
|
c(() => a);
|
|
} catch (_2) {
|
|
var _error2 = _2, _hasError2 = true;
|
|
} finally {
|
|
__callDispose(_stack2, _error2, _hasError2);
|
|
}
|
|
}
|
|
}
|
|
function foo() {
|
|
for (var _a of b) {
|
|
var _stack3 = [];
|
|
try {
|
|
const a = __using(_stack3, _a);
|
|
c(() => a);
|
|
} catch (_3) {
|
|
var _error3 = _3, _hasError3 = true;
|
|
} finally {
|
|
__callDispose(_stack3, _error3, _hasError3);
|
|
}
|
|
}
|
|
}
|
|
function bar() {
|
|
return __async(this, null, function* () {
|
|
for (var _a of b) {
|
|
var _stack3 = [];
|
|
try {
|
|
const a = __using(_stack3, _a);
|
|
c(() => a);
|
|
} catch (_3) {
|
|
var _error3 = _3, _hasError3 = true;
|
|
} finally {
|
|
__callDispose(_stack3, _error3, _hasError3);
|
|
}
|
|
}
|
|
for (var _d of e) {
|
|
var _stack4 = [];
|
|
try {
|
|
const d = __using(_stack4, _d, true);
|
|
f(() => d);
|
|
} catch (_4) {
|
|
var _error4 = _4, _hasError4 = true;
|
|
} finally {
|
|
var _promise = __callDispose(_stack4, _error4, _hasError4);
|
|
_promise && (yield _promise);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
================================================================================
|
|
TestStaticClassBlockES2021
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var _A = class _A {
|
|
};
|
|
_A.thisField++;
|
|
_A.classField++;
|
|
__superSet(_A, _A, "superField", __superGet(_A, _A, "superField") + 1);
|
|
__superWrapper(_A, _A, "superField")._++;
|
|
var A = _A;
|
|
var _a;
|
|
var B = (_a = class {
|
|
}, _a.thisField++, __superSet(_a, _a, "superField", __superGet(_a, _a, "superField") + 1), __superWrapper(_a, _a, "superField")._++, _a);
|
|
|
|
================================================================================
|
|
TestStaticClassBlockESNext
|
|
---------- /out.js ----------
|
|
// entry.js
|
|
var A = class _A {
|
|
static {
|
|
}
|
|
static {
|
|
this.thisField++;
|
|
_A.classField++;
|
|
super.superField = super.superField + 1;
|
|
super.superField++;
|
|
}
|
|
};
|
|
var B = class {
|
|
static {
|
|
}
|
|
static {
|
|
this.thisField++;
|
|
super.superField = super.superField + 1;
|
|
super.superField++;
|
|
}
|
|
};
|
|
|
|
================================================================================
|
|
TestTSLowerClassField2020NoBundle
|
|
---------- /out.js ----------
|
|
var _foo, _bar, _s_foo, _s_bar;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _foo, 123);
|
|
__privateAdd(this, _bar);
|
|
this.foo = 123;
|
|
}
|
|
}
|
|
_foo = new WeakMap();
|
|
_bar = new WeakMap();
|
|
_s_foo = new WeakMap();
|
|
_s_bar = new WeakMap();
|
|
__privateAdd(Foo, _s_foo, 123);
|
|
__privateAdd(Foo, _s_bar);
|
|
Foo.s_foo = 123;
|
|
|
|
================================================================================
|
|
TestTSLowerClassFieldStrictTsconfigJson2020
|
|
---------- /out.js ----------
|
|
// loose/index.ts
|
|
var loose_default = class {
|
|
};
|
|
|
|
// strict/index.ts
|
|
var strict_default = class {
|
|
constructor() {
|
|
__publicField(this, "foo");
|
|
}
|
|
};
|
|
|
|
// entry.js
|
|
console.log(loose_default, strict_default);
|
|
|
|
================================================================================
|
|
TestTSLowerClassPrivateFieldNextNoBundle
|
|
---------- /out.js ----------
|
|
class Foo {
|
|
constructor() {
|
|
this.#foo = 123;
|
|
this.foo = 123;
|
|
}
|
|
#foo;
|
|
#bar;
|
|
static #s_foo = 123;
|
|
static #s_bar;
|
|
static {
|
|
this.s_foo = 123;
|
|
}
|
|
}
|
|
|
|
================================================================================
|
|
TestTSLowerObjectRest2017NoBundle
|
|
---------- /out.js ----------
|
|
var _q, _r, _t, _u, _v, _w, _x;
|
|
const local_const = __objRest({}, []);
|
|
let local_let = __objRest({}, []);
|
|
var local_var = __objRest({}, []);
|
|
let arrow_fn = (_a) => {
|
|
var x2 = __objRest(_a, []);
|
|
};
|
|
let fn_expr = function(_b = default_value) {
|
|
var x2 = __objRest(_b, []);
|
|
};
|
|
let class_expr = class {
|
|
method(x2, ..._c) {
|
|
var [y, _d] = _c, z = __objRest(_d, []);
|
|
}
|
|
};
|
|
function fn_stmt(_e, _g) {
|
|
var _f = _e, { a = b() } = _f, x2 = __objRest(_f, ["a"]);
|
|
var _h = _g, { c = d() } = _h, y = __objRest(_h, ["c"]);
|
|
}
|
|
class class_stmt {
|
|
method(_i) {
|
|
var x2 = __objRest(_i, []);
|
|
}
|
|
}
|
|
var ns;
|
|
((ns2) => {
|
|
ns2.x = __objRest({}, []);
|
|
})(ns || (ns = {}));
|
|
try {
|
|
} catch (_j) {
|
|
let catch_clause = __objRest(_j, []);
|
|
}
|
|
for (const _k in { abc }) {
|
|
const for_in_const = __objRest(_k, []);
|
|
}
|
|
for (let _l in { abc }) {
|
|
let for_in_let = __objRest(_l, []);
|
|
}
|
|
for (var _m in { abc }) {
|
|
var for_in_var = __objRest(_m, []);
|
|
;
|
|
}
|
|
for (const _n of [{}]) {
|
|
const for_of_const = __objRest(_n, []);
|
|
;
|
|
}
|
|
for (let _o of [{}]) {
|
|
let for_of_let = __objRest(_o, []);
|
|
x();
|
|
}
|
|
for (var _p of [{}]) {
|
|
var for_of_var = __objRest(_p, []);
|
|
x();
|
|
}
|
|
for (const for_const = __objRest({}, []); x; x = null) {
|
|
}
|
|
for (let for_let = __objRest({}, []); x; x = null) {
|
|
}
|
|
for (var for_var = __objRest({}, []); x; x = null) {
|
|
}
|
|
for (_q in { abc }) {
|
|
x = __objRest(_q, []);
|
|
}
|
|
for (_r of [{}]) {
|
|
x = __objRest(_r, []);
|
|
}
|
|
for (x = __objRest({}, []); x; x = null) {
|
|
}
|
|
assign = __objRest({}, []);
|
|
({ obj_method(_s) {
|
|
var x2 = __objRest(_s, []);
|
|
} });
|
|
x = __objRest(x, []);
|
|
for (x = __objRest(x, []); 0; ) ;
|
|
console.log((x = __objRest(_t = x, []), _t));
|
|
console.log((_v = _u = { x }, { x } = _v, xx = __objRest(_v, ["x"]), _u));
|
|
console.log(({ x: _x } = _w = { x }, xx = __objRest(_x, []), _w));
|
|
|
|
================================================================================
|
|
TestTSLowerObjectRest2018NoBundle
|
|
---------- /out.js ----------
|
|
const { ...local_const } = {};
|
|
let { ...local_let } = {};
|
|
var { ...local_var } = {};
|
|
let arrow_fn = ({ ...x2 }) => {
|
|
};
|
|
let fn_expr = function({ ...x2 } = default_value) {
|
|
};
|
|
let class_expr = class {
|
|
method(x2, ...[y, { ...z }]) {
|
|
}
|
|
};
|
|
function fn_stmt({ a = b(), ...x2 }, { c = d(), ...y }) {
|
|
}
|
|
class class_stmt {
|
|
method({ ...x2 }) {
|
|
}
|
|
}
|
|
var ns;
|
|
((ns2) => {
|
|
({ ...ns2.x } = {});
|
|
})(ns || (ns = {}));
|
|
try {
|
|
} catch ({ ...catch_clause }) {
|
|
}
|
|
for (const { ...for_in_const } in { abc }) {
|
|
}
|
|
for (let { ...for_in_let } in { abc }) {
|
|
}
|
|
for (var { ...for_in_var } in { abc }) ;
|
|
for (const { ...for_of_const } of [{}]) ;
|
|
for (let { ...for_of_let } of [{}]) x();
|
|
for (var { ...for_of_var } of [{}]) x();
|
|
for (const { ...for_const } = {}; x; x = null) {
|
|
}
|
|
for (let { ...for_let } = {}; x; x = null) {
|
|
}
|
|
for (var { ...for_var } = {}; x; x = null) {
|
|
}
|
|
for ({ ...x } in { abc }) {
|
|
}
|
|
for ({ ...x } of [{}]) {
|
|
}
|
|
for ({ ...x } = {}; x; x = null) {
|
|
}
|
|
({ ...assign } = {});
|
|
({ obj_method({ ...x2 }) {
|
|
} });
|
|
({ ...x } = x);
|
|
for ({ ...x } = x; 0; ) ;
|
|
console.log({ ...x } = x);
|
|
console.log({ x, ...xx } = { x });
|
|
console.log({ x: { ...xx } } = { x });
|
|
|
|
================================================================================
|
|
TestTSLowerPrivateFieldAndMethodAvoidNameCollision2015
|
|
---------- /out.js ----------
|
|
// entry.ts
|
|
var _x;
|
|
var WeakMap2 = class {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
};
|
|
_x = new WeakMap();
|
|
var _WeakSet_instances, y_fn;
|
|
var WeakSet2 = class {
|
|
constructor() {
|
|
__privateAdd(this, _WeakSet_instances);
|
|
}
|
|
};
|
|
_WeakSet_instances = new WeakSet();
|
|
y_fn = function() {
|
|
};
|
|
export {
|
|
WeakMap2 as WeakMap,
|
|
WeakSet2 as WeakSet
|
|
};
|
|
|
|
================================================================================
|
|
TestTSLowerPrivateFieldOptionalChain2015NoBundle
|
|
---------- /out.js ----------
|
|
var _x;
|
|
class Foo {
|
|
constructor() {
|
|
__privateAdd(this, _x);
|
|
}
|
|
foo() {
|
|
var _a;
|
|
this == null ? void 0 : __privateGet(this, _x).y;
|
|
this == null ? void 0 : __privateGet(this.y, _x);
|
|
(_a = __privateGet(this, _x)) == null ? void 0 : _a.y;
|
|
}
|
|
}
|
|
_x = new WeakMap();
|
|
|
|
================================================================================
|
|
TestTSLowerPrivateStaticMembers2015NoBundle
|
|
---------- /out.js ----------
|
|
var _x, _Foo_static, y_get, y_set, z_fn;
|
|
const _Foo = class _Foo {
|
|
foo() {
|
|
var _a;
|
|
__privateSet(_Foo, _x, __privateGet(_Foo, _x) + 1);
|
|
__privateSet(_Foo, _Foo_static, __privateGet(_Foo, _Foo_static, y_get) + 1, y_set);
|
|
__privateMethod(_a = _Foo, _Foo_static, z_fn).call(_a);
|
|
}
|
|
};
|
|
_x = new WeakMap();
|
|
_Foo_static = new WeakSet();
|
|
y_get = function() {
|
|
};
|
|
y_set = function(x) {
|
|
};
|
|
z_fn = function() {
|
|
};
|
|
__privateAdd(_Foo, _Foo_static);
|
|
__privateAdd(_Foo, _x);
|
|
let Foo = _Foo;
|