fix(swc): Fix tests (#2707)

.github/workflows/cargo.yml

@@ -69,6 +69,13 @@ jobs:
     steps:
       - uses: actions/checkout@v2
 
+      - name: Checkout submodules
+        shell: bash
+        run: |
+          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
+          git submodule sync --recursive
+          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
+
       # We explicitly do this to cache properly.
       - name: Install Rust
         uses: actions-rs/toolchain@v1

crates/swc/tests/tsc-references/async/es2017/asyncMethodWithSuperConflict_es6/input.ts/es5.1.normal/output.js

@@ -179,6 +179,31 @@ function _toConsumableArray(arr) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = // @target: es6
 /*#__PURE__*/ function() {
     "use strict";
@@ -202,9 +227,10 @@ var A = // @target: es6
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super1 = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super1.apply(this, arguments);
     }
     _createClass(B, [
         {

crates/swc/tests/tsc-references/async/es2017/asyncMethodWithSuperConflict_es6/input.ts/es5.2.minified/output.js

@@ -112,14 +112,7 @@ var A = function() {
     ]), A;
 }(), B = function(A) {
     "use strict";
-    function B() {
-        var self, call, obj;
-        return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -128,7 +121,35 @@ var A = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(B, A), _createClass(B, [
+    }(B, A);
+    var _super1 = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(B);
+    function B() {
+        return _classCallCheck(this, B), _super1.apply(this, arguments);
+    }
+    return _createClass(B, [
         {
             key: "simple",
             value: function() {

crates/swc/tests/tsc-references/async/es2017/asyncMethodWithSuper_es2017/input.ts/es5.1.normal/output.js

@@ -179,6 +179,31 @@ function _toConsumableArray(arr) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = // @target: es2017
 // @noEmitHelpers: true
 /*#__PURE__*/ function() {
@@ -203,9 +228,10 @@ var A = // @target: es2017
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(B, [
         {

crates/swc/tests/tsc-references/async/es2017/asyncMethodWithSuper_es2017/input.ts/es5.2.minified/output.js

@@ -112,14 +112,7 @@ var A = function() {
     ]), A;
 }(), B = function(A) {
     "use strict";
-    function B() {
-        var self, call, obj;
-        return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -128,7 +121,35 @@ var A = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(B, A), _createClass(B, [
+    }(B, A);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(B);
+    function B() {
+        return _classCallCheck(this, B), _super.apply(this, arguments);
+    }
+    return _createClass(B, [
         {
             key: "simple",
             value: function() {

crates/swc/tests/tsc-references/async/es2017/awaitClassExpression_es2017/input.ts/es5.1.normal/output.js

@@ -74,6 +74,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 function _func() {
     _func = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
         var D;
@@ -83,9 +108,10 @@ function _func() {
                     _ctx.t0 = /*#__PURE__*/ function(_super) {
                         "use strict";
                         _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
                             _classCallCheck(this, D);
-                            return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _super1.apply(this, arguments);
                         }
                         return D;
                     };

crates/swc/tests/tsc-references/async/es2017/awaitClassExpression_es2017/input.ts/es5.2.minified/output.js

@@ -26,20 +26,35 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
 function _func() {
     return (_func = (function(fn) {
         return function() {
@@ -62,10 +77,12 @@ function _func() {
                 case 0:
                     return _ctx.t0 = function(_super) {
                         "use strict";
+                        _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
-                            return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _classCallCheck(this, D), _super1.apply(this, arguments);
                         }
-                        return _inherits(D, _super), D;
+                        return D;
                     }, _ctx.next = 3, p;
                 case 3:
                     _ctx.t1 = _ctx.sent, D = (0, _ctx.t0)(_ctx.t1);

crates/swc/tests/tsc-references/async/es5/asyncImportedPromise_es5/input.ts/es5.1.normal/output.js

@@ -146,6 +146,31 @@ function _wrapNativeSuper(Class) {
     };
     return _wrapNativeSuper(Class);
 }
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 // @target: es5
 // @lib: es5,es2015.promise
 // @module: commonjs
@@ -153,9 +178,10 @@ function _wrapNativeSuper(Class) {
 export var Task = /*#__PURE__*/ function(Promise) {
     "use strict";
     _inherits(Task, Promise);
+    var _super = _createSuper(Task);
     function Task() {
         _classCallCheck(this, Task);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Task).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Task;
 }(_wrapNativeSuper(Promise));

crates/swc/tests/tsc-references/async/es5/asyncImportedPromise_es5/input.ts/es5.2.minified/output.js

@@ -72,14 +72,7 @@ function _wrapNativeSuper(Class) {
 }
 export var _typeof, Task = function(Promise) {
     "use strict";
-    function Task() {
-        var self, call, obj;
-        return _classCallCheck(this, Task), self = this, call = _getPrototypeOf(Task).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -88,7 +81,35 @@ export var _typeof, Task = function(Promise) {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(Task, Promise), Task;
+    }(Task, Promise);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(Task);
+    function Task() {
+        return _classCallCheck(this, Task), _super.apply(this, arguments);
+    }
+    return Task;
 }(_wrapNativeSuper(Promise));
 var Test = function() {
     "use strict";

crates/swc/tests/tsc-references/async/es5/asyncMethodWithSuper_es5/input.ts/es5.1.normal/output.js

@@ -179,6 +179,31 @@ function _toConsumableArray(arr) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = // @target: ES5
 // @lib: es5,es2015.promise
 // @noEmitHelpers: true
@@ -204,9 +229,10 @@ var A = // @target: ES5
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(B, [
         {

crates/swc/tests/tsc-references/async/es5/asyncMethodWithSuper_es5/input.ts/es5.2.minified/output.js

@@ -112,14 +112,7 @@ var A = function() {
     ]), A;
 }(), B = function(A) {
     "use strict";
-    function B() {
-        var self, call, obj;
-        return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -128,7 +121,35 @@ var A = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(B, A), _createClass(B, [
+    }(B, A);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(B);
+    function B() {
+        return _classCallCheck(this, B), _super.apply(this, arguments);
+    }
+    return _createClass(B, [
         {
             key: "simple",
             value: function() {

crates/swc/tests/tsc-references/async/es5/awaitClassExpression_es5/input.ts/es5.1.normal/output.js

@@ -74,6 +74,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 function _func() {
     _func = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
         var D;
@@ -83,9 +108,10 @@ function _func() {
                     _ctx.t0 = /*#__PURE__*/ function(_super) {
                         "use strict";
                         _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
                             _classCallCheck(this, D);
-                            return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _super1.apply(this, arguments);
                         }
                         return D;
                     };

crates/swc/tests/tsc-references/async/es5/awaitClassExpression_es5/input.ts/es5.2.minified/output.js

@@ -26,20 +26,35 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
 function _func() {
     return (_func = (function(fn) {
         return function() {
@@ -62,10 +77,12 @@ function _func() {
                 case 0:
                     return _ctx.t0 = function(_super) {
                         "use strict";
+                        _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
-                            return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _classCallCheck(this, D), _super1.apply(this, arguments);
                         }
-                        return _inherits(D, _super), D;
+                        return D;
                     }, _ctx.next = 3, p;
                 case 3:
                     _ctx.t1 = _ctx.sent, D = (0, _ctx.t0)(_ctx.t1);

crates/swc/tests/tsc-references/async/es6/asyncImportedPromise_es6/input.ts/es5.1.normal/output.js

@@ -146,15 +146,41 @@ function _wrapNativeSuper(Class) {
     };
     return _wrapNativeSuper(Class);
 }
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 // @target: es6
 // @module: commonjs
 // @filename: task.ts
 export var Task = /*#__PURE__*/ function(Promise) {
     "use strict";
     _inherits(Task, Promise);
+    var _super = _createSuper(Task);
     function Task() {
         _classCallCheck(this, Task);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Task).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Task;
 }(_wrapNativeSuper(Promise));

crates/swc/tests/tsc-references/async/es6/asyncImportedPromise_es6/input.ts/es5.2.minified/output.js

@@ -72,14 +72,7 @@ function _wrapNativeSuper(Class) {
 }
 export var _typeof, Task = function(Promise) {
     "use strict";
-    function Task() {
-        var self, call, obj;
-        return _classCallCheck(this, Task), self = this, call = _getPrototypeOf(Task).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -88,7 +81,35 @@ export var _typeof, Task = function(Promise) {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(Task, Promise), Task;
+    }(Task, Promise);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(Task);
+    function Task() {
+        return _classCallCheck(this, Task), _super.apply(this, arguments);
+    }
+    return Task;
 }(_wrapNativeSuper(Promise));
 var Test = function() {
     "use strict";

crates/swc/tests/tsc-references/async/es6/asyncMethodWithSuper_es6/input.ts/es5.1.normal/output.js

@@ -268,6 +268,31 @@ function _wrapAsyncGenerator(fn) {
         return new AsyncGenerator(fn.apply(this, arguments));
     };
 }
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = // @target: ES6
 // @lib: esnext
 // @noEmitHelpers: true
@@ -293,9 +318,10 @@ var A = // @target: ES6
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(B, [
         {

crates/swc/tests/tsc-references/async/es6/asyncMethodWithSuper_es6/input.ts/es5.2.minified/output.js

@@ -180,14 +180,7 @@ var A = function() {
     ]), A;
 }(), B = function(A) {
     "use strict";
-    function B() {
-        var self, call, obj;
-        return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -196,7 +189,35 @@ var A = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(B, A), _createClass(B, [
+    }(B, A);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(B);
+    function B() {
+        return _classCallCheck(this, B), _super.apply(this, arguments);
+    }
+    return _createClass(B, [
         {
             key: "simple",
             value: function() {

crates/swc/tests/tsc-references/async/es6/awaitClassExpression_es6/input.ts/es5.1.normal/output.js

@@ -74,6 +74,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 function _func() {
     _func = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
         var D;
@@ -83,9 +108,10 @@ function _func() {
                     _ctx.t0 = /*#__PURE__*/ function(_super) {
                         "use strict";
                         _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
                             _classCallCheck(this, D);
-                            return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _super1.apply(this, arguments);
                         }
                         return D;
                     };

crates/swc/tests/tsc-references/async/es6/awaitClassExpression_es6/input.ts/es5.2.minified/output.js

@@ -26,20 +26,35 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
 function _func() {
     return (_func = (function(fn) {
         return function() {
@@ -62,10 +77,12 @@ function _func() {
                 case 0:
                     return _ctx.t0 = function(_super) {
                         "use strict";
+                        _inherits(D, _super);
+                        var _super1 = _createSuper(D);
                         function D() {
-                            return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+                            return _classCallCheck(this, D), _super1.apply(this, arguments);
                         }
-                        return _inherits(D, _super), D;
+                        return D;
                     }, _ctx.next = 3, p;
                 case 3:
                     _ctx.t1 = _ctx.sent, D = (0, _ctx.t0)(_ctx.t1);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -51,18 +76,20 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
 var C = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(B);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability/input.ts/es5.2.minified/output.js

@@ -16,33 +16,53 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A1), C = function(B) {
     "use strict";
+    _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, B), C;
+    return C;
 }(B);
 new B, new A1, new B;

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractExtends/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = /*#__PURE__*/ function() {
     "use strict";
     function A() {
@@ -75,36 +100,40 @@ var A = /*#__PURE__*/ function() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
 var C = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(B);
 var D = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(D, B);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D;
 }(B);
 var E = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(E, B);
+    var _super = _createSuper(E);
     function E() {
         _classCallCheck(this, E);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(E, [
         {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractExtends/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A = function() {
     "use strict";
     function A() {
         _classCallCheck(this, A);
@@ -52,28 +68,36 @@ var _typeof = function(obj) {
     ]), A;
 }(), B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A), C = function(B) {
     "use strict";
+    _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, B), C;
+    return C;
 }(B), D = function(B) {
     "use strict";
+    _inherits(D, B);
+    var _super = _createSuper(D);
     function D() {
-        return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _classCallCheck(this, D), _super.apply(this, arguments);
     }
-    return _inherits(D, B), D;
+    return D;
 }(B), E = function(B) {
     "use strict";
+    _inherits(E, B);
+    var _super = _createSuper(E);
     function E() {
-        return _classCallCheck(this, E), _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+        return _classCallCheck(this, E), _super.apply(this, arguments);
     }
-    return _inherits(E, B), _createClass(E, [
+    return _createClass(E, [
         {
             key: "bar",
             value: function() {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -51,9 +76,10 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction/input.ts/es5.2.minified/output.js

@@ -16,14 +16,7 @@ var A1 = function() {
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
-    function B() {
-        var self, call, obj;
-        return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -32,7 +25,35 @@ var A1 = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(B, A), B;
+    }(B, A);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(B);
+    function B() {
+        return _classCallCheck(this, B), _super.apply(this, arguments);
+    }
+    return B;
 }(A1);
 function NewA(Factory) {
     return new A1;

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -65,18 +90,20 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
 var C = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 } // error -- inherits abstract methods
@@ -84,9 +111,10 @@ var C = /*#__PURE__*/ function(A) {
 var D = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(D, A);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D;
 } // error -- inherits abstract methods
@@ -94,9 +122,10 @@ var D = /*#__PURE__*/ function(A) {
 var E = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(E, A);
+    var _super = _createSuper(E);
     function E() {
         _classCallCheck(this, E);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(E, [
         {
@@ -111,9 +140,10 @@ var E = /*#__PURE__*/ function(A) {
 var F = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(F, A);
+    var _super = _createSuper(F);
     function F() {
         _classCallCheck(this, F);
-        return _possibleConstructorReturn(this, _getPrototypeOf(F).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(F, [
         {
@@ -127,9 +157,10 @@ var F = /*#__PURE__*/ function(A) {
 var G = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(G, A);
+    var _super = _createSuper(G);
     function G() {
         _classCallCheck(this, G);
-        return _possibleConstructorReturn(this, _getPrototypeOf(G).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(G, [
         {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric/input.ts/es5.2.minified/output.js

@@ -25,46 +25,70 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A1), C = function(A) {
     "use strict";
+    _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, A), C;
+    return C;
 }(A1), D = function(A) {
     "use strict";
+    _inherits(D, A);
+    var _super = _createSuper(D);
     function D() {
-        return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _classCallCheck(this, D), _super.apply(this, arguments);
     }
-    return _inherits(D, A), D;
+    return D;
 }(A1), E = function(A) {
     "use strict";
+    _inherits(E, A);
+    var _super = _createSuper(E);
     function E() {
-        return _classCallCheck(this, E), _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+        return _classCallCheck(this, E), _super.apply(this, arguments);
     }
-    return _inherits(E, A), _createClass(E, [
+    return _createClass(E, [
         {
             key: "foo",
             value: function() {
@@ -74,10 +98,12 @@ var _typeof = function(obj) {
     ]), E;
 }(A1), F = function(A) {
     "use strict";
+    _inherits(F, A);
+    var _super = _createSuper(F);
     function F() {
-        return _classCallCheck(this, F), _possibleConstructorReturn(this, _getPrototypeOf(F).apply(this, arguments));
+        return _classCallCheck(this, F), _super.apply(this, arguments);
     }
-    return _inherits(F, A), _createClass(F, [
+    return _createClass(F, [
         {
             key: "bar",
             value: function(t) {
@@ -86,10 +112,12 @@ var _typeof = function(obj) {
     ]), F;
 }(A1), G = function(A) {
     "use strict";
+    _inherits(G, A);
+    var _super = _createSuper(G);
     function G() {
-        return _classCallCheck(this, G), _possibleConstructorReturn(this, _getPrototypeOf(G).apply(this, arguments));
+        return _classCallCheck(this, G), _super.apply(this, arguments);
     }
-    return _inherits(G, A), _createClass(G, [
+    return _createClass(G, [
         {
             key: "foo",
             value: function() {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var M1;
 (function(M) {
     var A = function A() {
@@ -54,9 +79,10 @@ var M1;
     var B = /*#__PURE__*/ function(A) {
         "use strict";
         _inherits(B, A);
+        var _super = _createSuper(B);
         function B() {
             _classCallCheck(this, B);
-            return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return B;
     }(A);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule/input.ts/es5.2.minified/output.js

@@ -20,14 +20,7 @@ function _setPrototypeOf(o, p) {
     M.A = A1;
     var B = function(A) {
         "use strict";
-        function B() {
-            var self, call, obj;
-            return _classCallCheck(this, B), self = this, call = _getPrototypeOf(B).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-                return self;
-            })(self);
-        }
-        return (function(subClass, superClass) {
+        !function(subClass, superClass) {
             if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
             subClass.prototype = Object.create(superClass && superClass.prototype, {
                 constructor: {
@@ -36,7 +29,35 @@ function _setPrototypeOf(o, p) {
                     configurable: !0
                 }
             }), superClass && _setPrototypeOf(subClass, superClass);
-        })(B, A), B;
+        }(B, A);
+        var _super = function(Derived) {
+            var hasNativeReflectConstruct = function() {
+                if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+                if (Reflect.construct.sham) return !1;
+                if ("function" == typeof Proxy) return !0;
+                try {
+                    return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                    })), !0;
+                } catch (e) {
+                    return !1;
+                }
+            }();
+            return function() {
+                var obj, self, call, result, Super = _getPrototypeOf(Derived);
+                if (hasNativeReflectConstruct) {
+                    var NewTarget = _getPrototypeOf(this).constructor;
+                    result = Reflect.construct(Super, arguments, NewTarget);
+                } else result = Super.apply(this, arguments);
+                return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                    if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                    return self;
+                })(self);
+            };
+        }(B);
+        function B() {
+            return _classCallCheck(this, B), _super.apply(this, arguments);
+        }
+        return B;
     }(A1);
     M.B = B;
 }(M1 || (M1 = {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -51,18 +76,20 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
 var C = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(A);
@@ -73,54 +100,60 @@ var AA = function AA() {
 var BB = /*#__PURE__*/ function(AA) {
     "use strict";
     _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
         _classCallCheck(this, BB);
-        return _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return BB;
 }(AA);
 var CC = /*#__PURE__*/ function(AA) {
     "use strict";
     _inherits(CC, AA);
+    var _super = _createSuper(CC);
     function CC() {
         _classCallCheck(this, CC);
-        return _possibleConstructorReturn(this, _getPrototypeOf(CC).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return CC;
 }(AA);
 var DD = /*#__PURE__*/ function(BB) {
     "use strict";
     _inherits(DD, BB);
+    var _super = _createSuper(DD);
     function DD() {
         _classCallCheck(this, DD);
-        return _possibleConstructorReturn(this, _getPrototypeOf(DD).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return DD;
 }(BB);
 var EE = /*#__PURE__*/ function(BB) {
     "use strict";
     _inherits(EE, BB);
+    var _super = _createSuper(EE);
     function EE() {
         _classCallCheck(this, EE);
-        return _possibleConstructorReturn(this, _getPrototypeOf(EE).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return EE;
 }(BB);
 var FF = /*#__PURE__*/ function(CC) {
     "use strict";
     _inherits(FF, CC);
+    var _super = _createSuper(FF);
     function FF() {
         _classCallCheck(this, FF);
-        return _possibleConstructorReturn(this, _getPrototypeOf(FF).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return FF;
 }(CC);
 var GG = /*#__PURE__*/ function(CC) {
     "use strict";
     _inherits(GG, CC);
+    var _super = _createSuper(GG);
     function GG() {
         _classCallCheck(this, GG);
-        return _possibleConstructorReturn(this, _getPrototypeOf(GG).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return GG;
 }(CC);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance/input.ts/es5.2.minified/output.js

@@ -16,71 +16,103 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A1), C = function(A) {
     "use strict";
+    _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, A), C;
+    return C;
 }(A1), AA1 = function() {
     "use strict";
     _classCallCheck(this, AA1);
 }, BB = function(AA) {
     "use strict";
+    _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
-        return _classCallCheck(this, BB), _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _classCallCheck(this, BB), _super.apply(this, arguments);
     }
-    return _inherits(BB, AA), BB;
+    return BB;
 }(AA1), CC = function(AA) {
     "use strict";
+    _inherits(CC, AA);
+    var _super = _createSuper(CC);
     function CC() {
-        return _classCallCheck(this, CC), _possibleConstructorReturn(this, _getPrototypeOf(CC).apply(this, arguments));
+        return _classCallCheck(this, CC), _super.apply(this, arguments);
     }
-    return _inherits(CC, AA), CC;
+    return CC;
 }(AA1), DD = function(BB) {
     "use strict";
+    _inherits(DD, BB);
+    var _super = _createSuper(DD);
     function DD() {
-        return _classCallCheck(this, DD), _possibleConstructorReturn(this, _getPrototypeOf(DD).apply(this, arguments));
+        return _classCallCheck(this, DD), _super.apply(this, arguments);
     }
-    return _inherits(DD, BB), DD;
+    return DD;
 }(BB), EE = function(BB) {
     "use strict";
+    _inherits(EE, BB);
+    var _super = _createSuper(EE);
     function EE() {
-        return _classCallCheck(this, EE), _possibleConstructorReturn(this, _getPrototypeOf(EE).apply(this, arguments));
+        return _classCallCheck(this, EE), _super.apply(this, arguments);
     }
-    return _inherits(EE, BB), EE;
+    return EE;
 }(BB), FF = function(CC) {
     "use strict";
+    _inherits(FF, CC);
+    var _super = _createSuper(FF);
     function FF() {
-        return _classCallCheck(this, FF), _possibleConstructorReturn(this, _getPrototypeOf(FF).apply(this, arguments));
+        return _classCallCheck(this, FF), _super.apply(this, arguments);
     }
-    return _inherits(FF, CC), FF;
+    return FF;
 }(CC), GG = function(CC) {
     "use strict";
+    _inherits(GG, CC);
+    var _super = _createSuper(GG);
     function GG() {
-        return _classCallCheck(this, GG), _possibleConstructorReturn(this, _getPrototypeOf(GG).apply(this, arguments));
+        return _classCallCheck(this, GG), _super.apply(this, arguments);
     }
-    return _inherits(GG, CC), GG;
+    return GG;
 }(CC);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -51,18 +76,20 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
 var C = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(B);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1/input.ts/es5.2.minified/output.js

@@ -16,33 +16,53 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A1), C = function(B) {
     "use strict";
+    _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, B), C;
+    return C;
 }(B);
 new A1, new A1(1), new B, new C, new B, new B, new B;

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractOverrideWithAbstract/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = /*#__PURE__*/ function() {
     "use strict";
     function A() {
@@ -75,9 +100,10 @@ var A = /*#__PURE__*/ function() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return B;
 }(A);
@@ -98,9 +124,10 @@ var AA = /*#__PURE__*/ function() {
 var BB = /*#__PURE__*/ function(AA) {
     "use strict";
     _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
         _classCallCheck(this, BB);
-        return _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(BB, [
         {
@@ -114,9 +141,10 @@ var BB = /*#__PURE__*/ function(AA) {
 var CC = /*#__PURE__*/ function(BB) {
     "use strict";
     _inherits(CC, BB);
+    var _super = _createSuper(CC);
     function CC() {
         _classCallCheck(this, CC);
-        return _possibleConstructorReturn(this, _getPrototypeOf(CC).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return CC;
 } // error
@@ -124,9 +152,10 @@ var CC = /*#__PURE__*/ function(BB) {
 var DD = /*#__PURE__*/ function(BB) {
     "use strict";
     _inherits(DD, BB);
+    var _super = _createSuper(DD);
     function DD() {
         _classCallCheck(this, DD);
-        return _possibleConstructorReturn(this, _getPrototypeOf(DD).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(DD, [
         {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractOverrideWithAbstract/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A = function() {
     "use strict";
     function A() {
         _classCallCheck(this, A);
@@ -52,10 +68,12 @@ var _typeof = function(obj) {
     ]), A;
 }(), B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), B;
+    return B;
 }(A), AA = function() {
     "use strict";
     function AA() {
@@ -70,10 +88,12 @@ var _typeof = function(obj) {
     ]), AA;
 }(), BB = function(AA) {
     "use strict";
+    _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
-        return _classCallCheck(this, BB), _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _classCallCheck(this, BB), _super.apply(this, arguments);
     }
-    return _inherits(BB, AA), _createClass(BB, [
+    return _createClass(BB, [
         {
             key: "bar",
             value: function() {
@@ -82,16 +102,20 @@ var _typeof = function(obj) {
     ]), BB;
 }(AA), CC = function(BB) {
     "use strict";
+    _inherits(CC, BB);
+    var _super = _createSuper(CC);
     function CC() {
-        return _classCallCheck(this, CC), _possibleConstructorReturn(this, _getPrototypeOf(CC).apply(this, arguments));
+        return _classCallCheck(this, CC), _super.apply(this, arguments);
     }
-    return _inherits(CC, BB), CC;
+    return CC;
 }(BB), DD = function(BB) {
     "use strict";
+    _inherits(DD, BB);
+    var _super = _createSuper(DD);
     function DD() {
-        return _classCallCheck(this, DD), _possibleConstructorReturn(this, _getPrototypeOf(DD).apply(this, arguments));
+        return _classCallCheck(this, DD), _super.apply(this, arguments);
     }
-    return _inherits(DD, BB), _createClass(DD, [
+    return _createClass(DD, [
         {
             key: "foo",
             value: function() {

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls/input.ts/es5.1.normal/output.js

@@ -81,6 +81,31 @@ function _superPropBase(object, property) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = /*#__PURE__*/ function() {
     "use strict";
     function A() {
@@ -99,9 +124,10 @@ var A = /*#__PURE__*/ function() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(B, [
         {
@@ -122,9 +148,10 @@ var B = /*#__PURE__*/ function(A) {
 var C = /*#__PURE__*/ function(B) {
     "use strict";
     _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(C, [
         {
@@ -172,9 +199,10 @@ var AA = /*#__PURE__*/ function() {
 var BB = /*#__PURE__*/ function(AA) {
     "use strict";
     _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
         _classCallCheck(this, BB);
-        return _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return BB;
 }(AA);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls/input.ts/es5.2.minified/output.js

@@ -34,12 +34,6 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
@@ -49,9 +43,31 @@ function _superPropBase(object, property) {
     for(; !Object.prototype.hasOwnProperty.call(object, property) && null !== (object = _getPrototypeOf(object)););
     return object;
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A = function() {
     "use strict";
     function A() {
         _classCallCheck(this, A);
@@ -66,10 +82,12 @@ var _typeof = function(obj) {
     ]), A;
 }(), B = function(A) {
     "use strict";
+    _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), _createClass(B, [
+    return _createClass(B, [
         {
             key: "bar",
             value: function() {
@@ -85,10 +103,12 @@ var _typeof = function(obj) {
     ]), B;
 }(A), C = function(B) {
     "use strict";
+    _inherits(C, B);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, B), _createClass(C, [
+    return _createClass(C, [
         {
             key: "foo",
             value: function() {
@@ -129,8 +149,10 @@ var _typeof = function(obj) {
     ]), AA;
 }(), BB = function(AA) {
     "use strict";
+    _inherits(BB, AA);
+    var _super = _createSuper(BB);
     function BB() {
-        return _classCallCheck(this, BB), _possibleConstructorReturn(this, _getPrototypeOf(BB).apply(this, arguments));
+        return _classCallCheck(this, BB), _super.apply(this, arguments);
     }
-    return _inherits(BB, AA), BB;
+    return BB;
 }(AA);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -65,9 +90,10 @@ var A = function A() {
 var B = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(B, A);
+    var _super = _createSuper(B);
     function B() {
         _classCallCheck(this, B);
-        return _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(B, [
         {
@@ -82,9 +108,10 @@ var B = /*#__PURE__*/ function(A) {
 var C = /*#__PURE__*/ function(A) {
     "use strict";
     _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(A);

crates/swc/tests/tsc-references/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1/input.ts/es5.2.minified/output.js

@@ -22,29 +22,46 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B = function(A) {
     "use strict";
-    var Constructor, protoProps, staticProps;
+    _inherits(B, A);
+    var Constructor, protoProps, staticProps, _super = _createSuper(B);
     function B() {
-        return _classCallCheck(this, B), _possibleConstructorReturn(this, _getPrototypeOf(B).apply(this, arguments));
+        return _classCallCheck(this, B), _super.apply(this, arguments);
     }
-    return _inherits(B, A), protoProps = [
+    return protoProps = [
         {
             key: "foo",
             value: function() {
@@ -54,9 +71,11 @@ var _typeof = function(obj) {
     ], _defineProperties((Constructor = B).prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), B;
 }(A1), C = function(A) {
     "use strict";
+    _inherits(C, A);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, A), C;
+    return C;
 }(A1), a = new B;
 a.foo(), (a = new C).foo();

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingBuiltinType/input.ts/es5.1.normal/output.js

@@ -102,93 +102,128 @@ function _wrapNativeSuper(Class) {
     };
     return _wrapNativeSuper(Class);
 }
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C1 = /*#__PURE__*/ function(Object) {
     "use strict";
     _inherits(C1, Object);
+    var _super = _createSuper(C1);
     function C1() {
         _classCallCheck(this, C1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C1;
 }(_wrapNativeSuper(Object));
 var C2 = /*#__PURE__*/ function(Function) {
     "use strict";
     _inherits(C2, Function);
+    var _super = _createSuper(C2);
     function C2() {
         _classCallCheck(this, C2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C2;
 }(_wrapNativeSuper(Function));
 var C3 = /*#__PURE__*/ function(String) {
     "use strict";
     _inherits(C3, String);
+    var _super = _createSuper(C3);
     function C3() {
         _classCallCheck(this, C3);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C3;
 }(_wrapNativeSuper(String));
 var C4 = /*#__PURE__*/ function(Boolean) {
     "use strict";
     _inherits(C4, Boolean);
+    var _super = _createSuper(C4);
     function C4() {
         _classCallCheck(this, C4);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C4;
 }(_wrapNativeSuper(Boolean));
 var C5 = /*#__PURE__*/ function(Number) {
     "use strict";
     _inherits(C5, Number);
+    var _super = _createSuper(C5);
     function C5() {
         _classCallCheck(this, C5);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C5).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C5;
 }(_wrapNativeSuper(Number));
 var C6 = /*#__PURE__*/ function(Date) {
     "use strict";
     _inherits(C6, Date);
+    var _super = _createSuper(C6);
     function C6() {
         _classCallCheck(this, C6);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C6).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C6;
 }(_wrapNativeSuper(Date));
 var C7 = /*#__PURE__*/ function(RegExp) {
     "use strict";
     _inherits(C7, RegExp);
+    var _super = _createSuper(C7);
     function C7() {
         _classCallCheck(this, C7);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C7).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C7;
 }(_wrapNativeSuper(RegExp));
 var C8 = /*#__PURE__*/ function(Error) {
     "use strict";
     _inherits(C8, Error);
+    var _super = _createSuper(C8);
     function C8() {
         _classCallCheck(this, C8);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C8).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C8;
 }(_wrapNativeSuper(Error));
 var C9 = /*#__PURE__*/ function(Array) {
     "use strict";
     _inherits(C9, Array);
+    var _super = _createSuper(C9);
     function C9() {
         _classCallCheck(this, C9);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C9).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C9;
 }(_wrapNativeSuper(Array));
 var C10 = /*#__PURE__*/ function(Array) {
     "use strict";
     _inherits(C10, Array);
+    var _super = _createSuper(C10);
     function C10() {
         _classCallCheck(this, C10);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C10).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C10;
 }(_wrapNativeSuper(Array));

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingBuiltinType/input.ts/es5.2.minified/output.js

@@ -36,20 +36,11 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
 function _wrapNativeSuper(Class) {
     var _cache = "function" == typeof Map ? new Map() : void 0;
     return _wrapNativeSuper = function _wrapNativeSuper(Class) {
@@ -73,64 +64,108 @@ function _wrapNativeSuper(Class) {
         }), _setPrototypeOf(Wrapper, Class);
     }, _wrapNativeSuper(Class);
 }
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
 var C1 = function(Object) {
     "use strict";
+    _inherits(C1, Object);
+    var _super = _createSuper(C1);
     function C1() {
-        return _classCallCheck(this, C1), _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _classCallCheck(this, C1), _super.apply(this, arguments);
     }
-    return _inherits(C1, Object), C1;
+    return C1;
 }(_wrapNativeSuper(Object)), C2 = function(Function) {
     "use strict";
+    _inherits(C2, Function);
+    var _super = _createSuper(C2);
     function C2() {
-        return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _classCallCheck(this, C2), _super.apply(this, arguments);
     }
-    return _inherits(C2, Function), C2;
+    return C2;
 }(_wrapNativeSuper(Function)), C3 = function(String) {
     "use strict";
+    _inherits(C3, String);
+    var _super = _createSuper(C3);
     function C3() {
-        return _classCallCheck(this, C3), _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments));
+        return _classCallCheck(this, C3), _super.apply(this, arguments);
     }
-    return _inherits(C3, String), C3;
+    return C3;
 }(_wrapNativeSuper(String)), C4 = function(Boolean) {
     "use strict";
+    _inherits(C4, Boolean);
+    var _super = _createSuper(C4);
     function C4() {
-        return _classCallCheck(this, C4), _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments));
+        return _classCallCheck(this, C4), _super.apply(this, arguments);
     }
-    return _inherits(C4, Boolean), C4;
+    return C4;
 }(_wrapNativeSuper(Boolean)), C5 = function(Number) {
     "use strict";
+    _inherits(C5, Number);
+    var _super = _createSuper(C5);
     function C5() {
-        return _classCallCheck(this, C5), _possibleConstructorReturn(this, _getPrototypeOf(C5).apply(this, arguments));
+        return _classCallCheck(this, C5), _super.apply(this, arguments);
     }
-    return _inherits(C5, Number), C5;
+    return C5;
 }(_wrapNativeSuper(Number)), C6 = function(Date) {
     "use strict";
+    _inherits(C6, Date);
+    var _super = _createSuper(C6);
     function C6() {
-        return _classCallCheck(this, C6), _possibleConstructorReturn(this, _getPrototypeOf(C6).apply(this, arguments));
+        return _classCallCheck(this, C6), _super.apply(this, arguments);
     }
-    return _inherits(C6, Date), C6;
+    return C6;
 }(_wrapNativeSuper(Date)), C7 = function(RegExp) {
     "use strict";
+    _inherits(C7, RegExp);
+    var _super = _createSuper(C7);
     function C7() {
-        return _classCallCheck(this, C7), _possibleConstructorReturn(this, _getPrototypeOf(C7).apply(this, arguments));
+        return _classCallCheck(this, C7), _super.apply(this, arguments);
     }
-    return _inherits(C7, RegExp), C7;
+    return C7;
 }(_wrapNativeSuper(RegExp)), C8 = function(Error) {
     "use strict";
+    _inherits(C8, Error);
+    var _super = _createSuper(C8);
     function C8() {
-        return _classCallCheck(this, C8), _possibleConstructorReturn(this, _getPrototypeOf(C8).apply(this, arguments));
+        return _classCallCheck(this, C8), _super.apply(this, arguments);
     }
-    return _inherits(C8, Error), C8;
+    return C8;
 }(_wrapNativeSuper(Error)), C9 = function(Array) {
     "use strict";
+    _inherits(C9, Array);
+    var _super = _createSuper(C9);
     function C9() {
-        return _classCallCheck(this, C9), _possibleConstructorReturn(this, _getPrototypeOf(C9).apply(this, arguments));
+        return _classCallCheck(this, C9), _super.apply(this, arguments);
     }
-    return _inherits(C9, Array), C9;
+    return C9;
 }(_wrapNativeSuper(Array)), C10 = function(Array) {
     "use strict";
+    _inherits(C10, Array);
+    var _super = _createSuper(C10);
     function C10() {
-        return _classCallCheck(this, C10), _possibleConstructorReturn(this, _getPrototypeOf(C10).apply(this, arguments));
+        return _classCallCheck(this, C10), _super.apply(this, arguments);
     }
-    return _inherits(C10, Array), C10;
+    return C10;
 }(_wrapNativeSuper(Array));

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingClassLikeType/input.ts/es5.1.normal/output.js

@@ -44,23 +44,50 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var D0 = // Error, no Base constructor function
 /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(D0, Base);
+    var _super = _createSuper(D0);
     function D0() {
         _classCallCheck(this, D0);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D0).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D0;
 }(Base);
 var D1 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(D1, _super);
+    var _super1 = _createSuper(D1);
     function D1() {
         _classCallCheck(this, D1);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D1).call(this, "abc", "def"));
+        _this = _super1.call(this, "abc", "def");
         _this.x = "x";
         _this.y = "y";
         return _this;
@@ -70,11 +97,12 @@ var D1 = /*#__PURE__*/ function(_super) {
 var D2 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(D2, _super);
+    var _super2 = _createSuper(D2);
     function D2() {
         _classCallCheck(this, D2);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).call(this, 10));
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).call(this, 10, 20));
+        _this = _super2.call(this, 10);
+        _this = _super2.call(this, 10, 20);
         _this.x = 1;
         _this.y = 2;
         return _this;
@@ -84,10 +112,11 @@ var D2 = /*#__PURE__*/ function(_super) {
 var D3 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(D3, _super);
+    var _super3 = _createSuper(D3);
     function D3() {
         _classCallCheck(this, D3);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D3).call(this, "abc", 42));
+        _this = _super3.call(this, "abc", 42);
         _this.x = "x";
         _this.y = 2;
         return _this;
@@ -98,9 +127,10 @@ var D4 = // Error, no constructors with three type arguments
 /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(D4, _super);
+    var _super4 = _createSuper(D4);
     function D4() {
         _classCallCheck(this, D4);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D4).apply(this, arguments));
+        return _super4.apply(this, arguments);
     }
     return D4;
 }(getBase());
@@ -108,9 +138,10 @@ var D5 = // Error, constructor return types differ
 /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(D5, _super);
+    var _super5 = _createSuper(D5);
     function D5() {
         _classCallCheck(this, D5);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D5).apply(this, arguments));
+        return _super5.apply(this, arguments);
     }
     return D5;
 }(getBadBase());

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingClassLikeType/input.ts/es5.2.minified/output.js

@@ -16,56 +16,84 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, D0 = function(Base) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var D0 = function(Base) {
     "use strict";
+    _inherits(D0, Base);
+    var _super = _createSuper(D0);
     function D0() {
-        return _classCallCheck(this, D0), _possibleConstructorReturn(this, _getPrototypeOf(D0).apply(this, arguments));
+        return _classCallCheck(this, D0), _super.apply(this, arguments);
     }
-    return _inherits(D0, Base), D0;
+    return D0;
 }(Base), D1 = function(_super) {
     "use strict";
+    _inherits(D1, _super);
+    var _super1 = _createSuper(D1);
     function D1() {
         var _this;
-        return _classCallCheck(this, D1), (_this = _possibleConstructorReturn(this, _getPrototypeOf(D1).call(this, "abc", "def"))).x = "x", _this.y = "y", _this;
+        return _classCallCheck(this, D1), (_this = _super1.call(this, "abc", "def")).x = "x", _this.y = "y", _this;
     }
-    return _inherits(D1, _super), D1;
+    return D1;
 }(getBase()), D2 = function(_super) {
     "use strict";
+    _inherits(D2, _super);
+    var _super2 = _createSuper(D2);
     function D2() {
         var _this;
-        return _classCallCheck(this, D2), _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).call(this, 10)), _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).call(this, 10, 20)), _this.x = 1, _this.y = 2, _this;
+        return _classCallCheck(this, D2), _this = _super2.call(this, 10), _this = _super2.call(this, 10, 20), _this.x = 1, _this.y = 2, _this;
     }
-    return _inherits(D2, _super), D2;
+    return D2;
 }(getBase()), D3 = function(_super) {
     "use strict";
+    _inherits(D3, _super);
+    var _super3 = _createSuper(D3);
     function D3() {
         var _this;
-        return _classCallCheck(this, D3), (_this = _possibleConstructorReturn(this, _getPrototypeOf(D3).call(this, "abc", 42))).x = "x", _this.y = 2, _this;
+        return _classCallCheck(this, D3), (_this = _super3.call(this, "abc", 42)).x = "x", _this.y = 2, _this;
     }
-    return _inherits(D3, _super), D3;
+    return D3;
 }(getBase()), D4 = function(_super) {
     "use strict";
+    _inherits(D4, _super);
+    var _super4 = _createSuper(D4);
     function D4() {
-        return _classCallCheck(this, D4), _possibleConstructorReturn(this, _getPrototypeOf(D4).apply(this, arguments));
+        return _classCallCheck(this, D4), _super4.apply(this, arguments);
     }
-    return _inherits(D4, _super), D4;
+    return D4;
 }(getBase()), D5 = function(_super) {
     "use strict";
+    _inherits(D5, _super);
+    var _super5 = _createSuper(D5);
     function D5() {
-        return _classCallCheck(this, D5), _possibleConstructorReturn(this, _getPrototypeOf(D5).apply(this, arguments));
+        return _classCallCheck(this, D5), _super5.apply(this, arguments);
     }
-    return _inherits(D5, _super), D5;
+    return D5;
 }(getBadBase());

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingNonConstructor/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var x1;
 function foo1() {
     this.x = 1;
@@ -51,63 +76,70 @@ function foo1() {
 var C1 = /*#__PURE__*/ function(undefined) {
     "use strict";
     _inherits(C1, undefined);
+    var _super = _createSuper(C1);
     function C1() {
         _classCallCheck(this, C1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C1;
 }(undefined);
 var C2 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C2, _super);
+    var _super1 = _createSuper(C2);
     function C2() {
         _classCallCheck(this, C2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _super1.apply(this, arguments);
     }
     return C2;
 }(true);
 var C3 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C3, _super);
+    var _super2 = _createSuper(C3);
     function C3() {
         _classCallCheck(this, C3);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments));
+        return _super2.apply(this, arguments);
     }
     return C3;
 }(false);
 var C4 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C4, _super);
+    var _super3 = _createSuper(C4);
     function C4() {
         _classCallCheck(this, C4);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments));
+        return _super3.apply(this, arguments);
     }
     return C4;
 }(42);
 var C5 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C5, _super);
+    var _super4 = _createSuper(C5);
     function C5() {
         _classCallCheck(this, C5);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C5).apply(this, arguments));
+        return _super4.apply(this, arguments);
     }
     return C5;
 }("hello");
 var C6 = /*#__PURE__*/ function(x) {
     "use strict";
     _inherits(C6, x);
+    var _super = _createSuper(C6);
     function C6() {
         _classCallCheck(this, C6);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C6).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C6;
 }(x1);
 var C7 = /*#__PURE__*/ function(foo) {
     "use strict";
     _inherits(C7, foo);
+    var _super = _createSuper(C7);
     function C7() {
         _classCallCheck(this, C7);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C7).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C7;
 }(foo1);

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingNonConstructor/input.ts/es5.2.minified/output.js

@@ -16,61 +16,91 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var x1, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C1 = function(undefined) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var x1, C1 = function(undefined) {
     "use strict";
+    _inherits(C1, undefined);
+    var _super = _createSuper(C1);
     function C1() {
-        return _classCallCheck(this, C1), _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _classCallCheck(this, C1), _super.apply(this, arguments);
     }
-    return _inherits(C1, undefined), C1;
+    return C1;
 }(void 0), C2 = function(_super) {
     "use strict";
+    _inherits(C2, _super);
+    var _super1 = _createSuper(C2);
     function C2() {
-        return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _classCallCheck(this, C2), _super1.apply(this, arguments);
     }
-    return _inherits(C2, _super), C2;
+    return C2;
 }(!0), C3 = function(_super) {
     "use strict";
+    _inherits(C3, _super);
+    var _super2 = _createSuper(C3);
     function C3() {
-        return _classCallCheck(this, C3), _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments));
+        return _classCallCheck(this, C3), _super2.apply(this, arguments);
     }
-    return _inherits(C3, _super), C3;
+    return C3;
 }(!1), C4 = function(_super) {
     "use strict";
+    _inherits(C4, 42);
+    var _super3 = _createSuper(C4);
     function C4() {
-        return _classCallCheck(this, C4), _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments));
+        return _classCallCheck(this, C4), _super3.apply(this, arguments);
     }
-    return _inherits(C4, 42), C4;
+    return C4;
 }(42), C5 = function(_super) {
     "use strict";
+    _inherits(C5, "hello");
+    var _super4 = _createSuper(C5);
     function C5() {
-        return _classCallCheck(this, C5), _possibleConstructorReturn(this, _getPrototypeOf(C5).apply(this, arguments));
+        return _classCallCheck(this, C5), _super4.apply(this, arguments);
     }
-    return _inherits(C5, "hello"), C5;
+    return C5;
 }("hello"), C6 = function(x) {
     "use strict";
+    _inherits(C6, x);
+    var _super = _createSuper(C6);
     function C6() {
-        return _classCallCheck(this, C6), _possibleConstructorReturn(this, _getPrototypeOf(C6).apply(this, arguments));
+        return _classCallCheck(this, C6), _super.apply(this, arguments);
     }
-    return _inherits(C6, x), C6;
+    return C6;
 }(x1), C7 = function(foo) {
     "use strict";
+    _inherits(C7, foo);
+    var _super = _createSuper(C7);
     function C7() {
-        return _classCallCheck(this, C7), _possibleConstructorReturn(this, _getPrototypeOf(C7).apply(this, arguments));
+        return _classCallCheck(this, C7), _super.apply(this, arguments);
     }
-    return _inherits(C7, foo), C7;
+    return C7;
 }(function() {
     this.x = 1;
 });

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingNull/input.ts/es5.1.normal/output.js

@@ -44,31 +44,59 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C1 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C1, _super);
+    var _super1 = _createSuper(C1);
     function C1() {
         _classCallCheck(this, C1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _super1.apply(this, arguments);
     }
     return C1;
 }(null);
 var C2 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C2, _super);
+    var _super2 = _createSuper(C2);
     function C2() {
         _classCallCheck(this, C2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _super2.apply(this, arguments);
     }
     return C2;
 }(null);
 var C3 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C3, _super);
+    var _super3 = _createSuper(C3);
     function C3() {
         _classCallCheck(this, C3);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments));
+        _this = _super3.apply(this, arguments);
         _this.x = 1;
         return _this;
     }
@@ -77,10 +105,11 @@ var C3 = /*#__PURE__*/ function(_super) {
 var C4 = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C4, _super);
+    var _super4 = _createSuper(C4);
     function C4() {
         _classCallCheck(this, C4);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments));
+        _this = _super4.apply(this, arguments);
         _this.x = 1;
         return _this;
     }

crates/swc/tests/tsc-references/classes/classDeclarations/classExtendingNull/input.ts/es5.2.minified/output.js

@@ -16,43 +16,67 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C1 = function(_super) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var C1 = function(_super) {
     "use strict";
+    _inherits(C1, null);
+    var _super1 = _createSuper(C1);
     function C1() {
-        return _classCallCheck(this, C1), _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _classCallCheck(this, C1), _super1.apply(this, arguments);
     }
-    return _inherits(C1, null), C1;
+    return C1;
 }(null), C2 = function(_super) {
     "use strict";
+    _inherits(C2, null);
+    var _super2 = _createSuper(C2);
     function C2() {
-        return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _classCallCheck(this, C2), _super2.apply(this, arguments);
     }
-    return _inherits(C2, null), C2;
+    return C2;
 }(null), C3 = function(_super) {
     "use strict";
+    _inherits(C3, null);
+    var _super3 = _createSuper(C3);
     function C3() {
         var _this;
-        return _classCallCheck(this, C3), _this = _possibleConstructorReturn(this, _getPrototypeOf(C3).apply(this, arguments)), _this.x = 1, _this;
+        return _classCallCheck(this, C3), _this = _super3.apply(this, arguments), _this.x = 1, _this;
     }
-    return _inherits(C3, null), C3;
+    return C3;
 }(null), C4 = function(_super) {
     "use strict";
+    _inherits(C4, null);
+    var _super4 = _createSuper(C4);
     function C4() {
         var _this;
-        return _classCallCheck(this, C4), _this = _possibleConstructorReturn(this, _getPrototypeOf(C4).apply(this, arguments)), _this.x = 1, _this;
+        return _classCallCheck(this, C4), _this = _super4.apply(this, arguments), _this.x = 1, _this;
     }
-    return _inherits(C4, null), C4;
+    return C4;
 }(null);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendingClass/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = /*#__PURE__*/ function() {
     "use strict";
     function C() {
@@ -81,9 +106,10 @@ var C = /*#__PURE__*/ function() {
 var D = /*#__PURE__*/ function(C) {
     "use strict";
     _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D;
 }(C);
@@ -115,9 +141,10 @@ var C2 = /*#__PURE__*/ function() {
 var D2 = /*#__PURE__*/ function(C2) {
     "use strict";
     _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
         _classCallCheck(this, D2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D2;
 }(C2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendingClass/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var d, d2, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var d, d2, C = function() {
     "use strict";
     function C() {
         _classCallCheck(this, C);
@@ -58,10 +74,12 @@ var d, d2, _typeof = function(obj) {
     ]), C;
 }(), D = function(C) {
     "use strict";
+    _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
-        return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _classCallCheck(this, D), _super.apply(this, arguments);
     }
-    return _inherits(D, C), D;
+    return D;
 }(C);
 d.foo, d.bar, d.thing(), D.other();
 var C2 = function() {
@@ -84,9 +102,11 @@ var C2 = function() {
     ]), C2;
 }(), D2 = function(C2) {
     "use strict";
+    _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
-        return _classCallCheck(this, D2), _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _classCallCheck(this, D2), _super.apply(this, arguments);
     }
-    return _inherits(D2, C2), D2;
+    return D2;
 }(C2);
 d2.foo, d2.bar, d2.thing(""), D2.other(1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItself/input.ts/es5.1.normal/output.js

@@ -44,12 +44,38 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C1 = /*#__PURE__*/ function(C) {
     "use strict";
     _inherits(C1, C);
+    var _super = _createSuper(C1);
     function C1() {
         _classCallCheck(this, C1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C1;
 } // error
@@ -57,9 +83,10 @@ var C1 = /*#__PURE__*/ function(C) {
 var D1 = /*#__PURE__*/ function(D) {
     "use strict";
     _inherits(D1, D);
+    var _super = _createSuper(D1);
     function D1() {
         _classCallCheck(this, D1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D1;
 } // error
@@ -67,9 +94,10 @@ var D1 = /*#__PURE__*/ function(D) {
 var E1 = /*#__PURE__*/ function(E) {
     "use strict";
     _inherits(E1, E);
+    var _super = _createSuper(E1);
     function E1() {
         _classCallCheck(this, E1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return E1;
 } // error

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItself/input.ts/es5.2.minified/output.js

@@ -16,36 +16,58 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C1 = function(C) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var C1 = function(C) {
     "use strict";
+    _inherits(C1, C);
+    var _super = _createSuper(C1);
     function C1() {
-        return _classCallCheck(this, C1), _possibleConstructorReturn(this, _getPrototypeOf(C1).apply(this, arguments));
+        return _classCallCheck(this, C1), _super.apply(this, arguments);
     }
-    return _inherits(C1, C), C1;
+    return C1;
 }(C1), D1 = function(D) {
     "use strict";
+    _inherits(D1, D);
+    var _super = _createSuper(D1);
     function D1() {
-        return _classCallCheck(this, D1), _possibleConstructorReturn(this, _getPrototypeOf(D1).apply(this, arguments));
+        return _classCallCheck(this, D1), _super.apply(this, arguments);
     }
-    return _inherits(D1, D), D1;
+    return D1;
 }(D1), E1 = function(E) {
     "use strict";
+    _inherits(E1, E);
+    var _super = _createSuper(E1);
     function E1() {
-        return _classCallCheck(this, E1), _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _classCallCheck(this, E1), _super.apply(this, arguments);
     }
-    return _inherits(E1, E), E1;
+    return E1;
 } // error
 (E1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly/input.ts/es5.1.normal/output.js

@@ -44,12 +44,38 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = /*#__PURE__*/ function(E) {
     "use strict";
     _inherits(C, E);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 } // error
@@ -57,27 +83,30 @@ var C = /*#__PURE__*/ function(E) {
 var D = /*#__PURE__*/ function(C) {
     "use strict";
     _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D;
 }(C);
 var E1 = /*#__PURE__*/ function(D) {
     "use strict";
     _inherits(E1, D);
+    var _super = _createSuper(E1);
     function E1() {
         _classCallCheck(this, E1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return E1;
 }(D);
 var C2 = /*#__PURE__*/ function(E2) {
     "use strict";
     _inherits(C2, E2);
+    var _super = _createSuper(C2);
     function C2() {
         _classCallCheck(this, C2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C2;
 } // error
@@ -85,18 +114,20 @@ var C2 = /*#__PURE__*/ function(E2) {
 var D2 = /*#__PURE__*/ function(C2) {
     "use strict";
     _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
         _classCallCheck(this, D2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D2;
 }(C2);
 var E21 = /*#__PURE__*/ function(D2) {
     "use strict";
     _inherits(E21, D2);
+    var _super = _createSuper(E21);
     function E21() {
         _classCallCheck(this, E21);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E21).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return E21;
 }(D2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly/input.ts/es5.2.minified/output.js

@@ -16,53 +16,81 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function(E) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var C = function(E) {
     "use strict";
+    _inherits(C, E);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, E), C;
+    return C;
 }(E1), D = function(C) {
     "use strict";
+    _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
-        return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _classCallCheck(this, D), _super.apply(this, arguments);
     }
-    return _inherits(D, C), D;
+    return D;
 }(C), E1 = function(D) {
     "use strict";
+    _inherits(E1, D);
+    var _super = _createSuper(E1);
     function E1() {
-        return _classCallCheck(this, E1), _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _classCallCheck(this, E1), _super.apply(this, arguments);
     }
-    return _inherits(E1, D), E1;
+    return E1;
 }(D), C2 = function(E2) {
     "use strict";
+    _inherits(C2, E2);
+    var _super = _createSuper(C2);
     function C2() {
-        return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _classCallCheck(this, C2), _super.apply(this, arguments);
     }
-    return _inherits(C2, E2), C2;
+    return C2;
 }(E21), D2 = function(C2) {
     "use strict";
+    _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
-        return _classCallCheck(this, D2), _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _classCallCheck(this, D2), _super.apply(this, arguments);
     }
-    return _inherits(D2, C2), D2;
+    return D2;
 }(C2), E21 = function(D2) {
     "use strict";
+    _inherits(E21, D2);
+    var _super = _createSuper(E21);
     function E21() {
-        return _classCallCheck(this, E21), _possibleConstructorReturn(this, _getPrototypeOf(E21).apply(this, arguments));
+        return _classCallCheck(this, E21), _super.apply(this, arguments);
     }
-    return _inherits(E21, D2), E21;
+    return E21;
 }(D2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2/input.ts/es5.1.normal/output.js

@@ -44,12 +44,38 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = /*#__PURE__*/ function(_E) {
     "use strict";
     _inherits(C, _E);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 } // error
@@ -59,9 +85,10 @@ var M1;
     var D = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(D, C);
+        var _super = _createSuper(D);
         function D() {
             _classCallCheck(this, D);
-            return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return D;
     }(C);
@@ -73,9 +100,10 @@ var N1;
     var E = /*#__PURE__*/ function(_D) {
         "use strict";
         _inherits(E, _D);
+        var _super = _createSuper(E);
         function E() {
             _classCallCheck(this, E);
-            return _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return E;
     }(M1.D);
@@ -87,9 +115,10 @@ var O;
     var C2 = /*#__PURE__*/ function(_E2) {
         "use strict";
         _inherits(C2, _E2);
+        var _super = _createSuper(C2);
         function C2() {
             _classCallCheck(this, C2);
-            return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return C2;
     } // error
@@ -99,9 +128,10 @@ var O;
         var D2 = /*#__PURE__*/ function(C2) {
             "use strict";
             _inherits(D2, C2);
+            var _super = _createSuper(D2);
             function D2() {
                 _classCallCheck(this, D2);
-                return _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+                return _super.apply(this, arguments);
             }
             return D2;
         }(C2);
@@ -113,9 +143,10 @@ var O;
         var E2 = /*#__PURE__*/ function(_D2) {
             "use strict";
             _inherits(E2, _D2);
+            var _super = _createSuper(E2);
             function E2() {
                 _classCallCheck(this, E2);
-                return _possibleConstructorReturn(this, _getPrototypeOf(E2).apply(this, arguments));
+                return _super.apply(this, arguments);
             }
             return E2;
         }(P1.D2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2/input.ts/es5.2.minified/output.js

@@ -16,71 +16,99 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var M1, N1, O, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function(_E) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var M1, N1, O, C = function(_E) {
     "use strict";
+    _inherits(C, _E);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, _E), C;
+    return C;
 }(N1.E);
 !function(M) {
     var D = function(C) {
         "use strict";
+        _inherits(D, C);
+        var _super = _createSuper(D);
         function D() {
-            return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+            return _classCallCheck(this, D), _super.apply(this, arguments);
         }
-        return _inherits(D, C), D;
+        return D;
     }(C);
     M.D = D;
 }(M1 || (M1 = {
 })), (function(N) {
     var E = function(_D) {
         "use strict";
+        _inherits(E, _D);
+        var _super = _createSuper(E);
         function E() {
-            return _classCallCheck(this, E), _possibleConstructorReturn(this, _getPrototypeOf(E).apply(this, arguments));
+            return _classCallCheck(this, E), _super.apply(this, arguments);
         }
-        return _inherits(E, _D), E;
+        return E;
     }(M1.D);
     N.E = E;
 })(N1 || (N1 = {
 })), (function(O) {
     var P1, Q1, C2 = function(_E2) {
         "use strict";
+        _inherits(C2, _E2);
+        var _super = _createSuper(C2);
         function C2() {
-            return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+            return _classCallCheck(this, C2), _super.apply(this, arguments);
         }
-        return _inherits(C2, _E2), C2;
+        return C2;
     }(Q1.E2);
     (function(P) {
         var D2 = function(C2) {
             "use strict";
+            _inherits(D2, C2);
+            var _super = _createSuper(D2);
             function D2() {
-                return _classCallCheck(this, D2), _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+                return _classCallCheck(this, D2), _super.apply(this, arguments);
             }
-            return _inherits(D2, C2), D2;
+            return D2;
         }(C2);
         P.D2 = D2;
     })(P1 || (P1 = {
     })), (function(Q) {
         var E2 = function(_D2) {
             "use strict";
+            _inherits(E2, _D2);
+            var _super = _createSuper(E2);
             function E2() {
-                return _classCallCheck(this, E2), _possibleConstructorReturn(this, _getPrototypeOf(E2).apply(this, arguments));
+                return _classCallCheck(this, E2), _super.apply(this, arguments);
             }
-            return _inherits(E2, _D2), E2;
+            return E2;
         }(P1.D2);
         Q.E2 = E2;
     })(Q1 || (Q1 = {

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly3/input.ts/es5.1.normal/output.js

@@ -44,13 +44,39 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = // @Filename: classExtendsItselfIndirectly_file1.ts
 /*#__PURE__*/ function(E) {
     "use strict";
     _inherits(C, E);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 } // error
@@ -59,9 +85,10 @@ var D = // @Filename: classExtendsItselfIndirectly_file2.ts
 /*#__PURE__*/ function(C) {
     "use strict";
     _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D;
 }(C);
@@ -69,9 +96,10 @@ var E1 = // @Filename: classExtendsItselfIndirectly_file3.ts
 /*#__PURE__*/ function(D) {
     "use strict";
     _inherits(E1, D);
+    var _super = _createSuper(E1);
     function E1() {
         _classCallCheck(this, E1);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return E1;
 }(D);
@@ -79,9 +107,10 @@ var C2 = // @Filename: classExtendsItselfIndirectly_file4.ts
 /*#__PURE__*/ function(E2) {
     "use strict";
     _inherits(C2, E2);
+    var _super = _createSuper(C2);
     function C2() {
         _classCallCheck(this, C2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C2;
 } // error
@@ -90,9 +119,10 @@ var D2 = // @Filename: classExtendsItselfIndirectly_file5.ts
 /*#__PURE__*/ function(C2) {
     "use strict";
     _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
         _classCallCheck(this, D2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return D2;
 }(C2);
@@ -100,9 +130,10 @@ var E21 = // @Filename: classExtendsItselfIndirectly_file6.ts
 /*#__PURE__*/ function(D2) {
     "use strict";
     _inherits(E21, D2);
+    var _super = _createSuper(E21);
     function E21() {
         _classCallCheck(this, E21);
-        return _possibleConstructorReturn(this, _getPrototypeOf(E21).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return E21;
 }(D2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly3/input.ts/es5.2.minified/output.js

@@ -16,53 +16,81 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function(E) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var C = function(E) {
     "use strict";
+    _inherits(C, E);
+    var _super = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super.apply(this, arguments);
     }
-    return _inherits(C, E), C;
+    return C;
 }(E1), D = function(C) {
     "use strict";
+    _inherits(D, C);
+    var _super = _createSuper(D);
     function D() {
-        return _classCallCheck(this, D), _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        return _classCallCheck(this, D), _super.apply(this, arguments);
     }
-    return _inherits(D, C), D;
+    return D;
 }(C), E1 = function(D) {
     "use strict";
+    _inherits(E1, D);
+    var _super = _createSuper(E1);
     function E1() {
-        return _classCallCheck(this, E1), _possibleConstructorReturn(this, _getPrototypeOf(E1).apply(this, arguments));
+        return _classCallCheck(this, E1), _super.apply(this, arguments);
     }
-    return _inherits(E1, D), E1;
+    return E1;
 }(D), C2 = function(E2) {
     "use strict";
+    _inherits(C2, E2);
+    var _super = _createSuper(C2);
     function C2() {
-        return _classCallCheck(this, C2), _possibleConstructorReturn(this, _getPrototypeOf(C2).apply(this, arguments));
+        return _classCallCheck(this, C2), _super.apply(this, arguments);
     }
-    return _inherits(C2, E2), C2;
+    return C2;
 }(E21), D2 = function(C2) {
     "use strict";
+    _inherits(D2, C2);
+    var _super = _createSuper(D2);
     function D2() {
-        return _classCallCheck(this, D2), _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        return _classCallCheck(this, D2), _super.apply(this, arguments);
     }
-    return _inherits(D2, C2), D2;
+    return D2;
 }(C2), E21 = function(D2) {
     "use strict";
+    _inherits(E21, D2);
+    var _super = _createSuper(E21);
     function E21() {
-        return _classCallCheck(this, E21), _possibleConstructorReturn(this, _getPrototypeOf(E21).apply(this, arguments));
+        return _classCallCheck(this, E21), _super.apply(this, arguments);
     }
-    return _inherits(E21, D2), E21;
+    return E21;
 }(D2);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsShadowedConstructorFunction/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = function C() {
     "use strict";
     _classCallCheck(this, C);
@@ -54,9 +79,10 @@ var M;
     var D = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(D, C);
+        var _super = _createSuper(D);
         function D() {
             _classCallCheck(this, D);
-            return _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return D;
     }(C1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsShadowedConstructorFunction/input.ts/es5.2.minified/output.js

@@ -18,14 +18,7 @@ var M, C = function() {
 !function(M) {
     var D = function(C) {
         "use strict";
-        function D() {
-            var self, call, obj;
-            return _classCallCheck(this, D), self = this, call = _getPrototypeOf(D).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-                return self;
-            })(self);
-        }
-        return !function(subClass, superClass) {
+        !function(subClass, superClass) {
             if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
             subClass.prototype = Object.create(superClass && superClass.prototype, {
                 constructor: {
@@ -34,7 +27,35 @@ var M, C = function() {
                     configurable: !0
                 }
             }), superClass && _setPrototypeOf(subClass, superClass);
-        }(D, 1), D;
+        }(D, 1);
+        var _super = function(Derived) {
+            var hasNativeReflectConstruct = function() {
+                if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+                if (Reflect.construct.sham) return !1;
+                if ("function" == typeof Proxy) return !0;
+                try {
+                    return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                    })), !0;
+                } catch (e) {
+                    return !1;
+                }
+            }();
+            return function() {
+                var obj, self, call, result, Super = _getPrototypeOf(Derived);
+                if (hasNativeReflectConstruct) {
+                    var NewTarget = _getPrototypeOf(this).constructor;
+                    result = Reflect.construct(Super, arguments, NewTarget);
+                } else result = Super.apply(this, arguments);
+                return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                    if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                    return self;
+                })(self);
+            };
+        }(D);
+        function D() {
+            return _classCallCheck(this, D), _super.apply(this, arguments);
+        }
+        return D;
     }(1);
 }(M || (M = {
 }));

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsValidConstructorFunction/input.ts/es5.1.normal/output.js

@@ -44,15 +44,41 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 function foo1() {
 }
 var x = new foo1(); // can be used as a constructor function
 var C = /*#__PURE__*/ function(foo) {
     "use strict";
     _inherits(C, foo);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 } // error, cannot extend it though

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classExtendsValidConstructorFunction/input.ts/es5.2.minified/output.js

@@ -13,16 +13,7 @@ function foo1() {
 new foo1();
 var C = function(foo) {
     "use strict";
-    function C() {
-        var self, call, obj;
-        return !function(instance, Constructor) {
-            if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-        }(this, C), self = this, call = _getPrototypeOf(C).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -31,6 +22,36 @@ var C = function(foo) {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(C, foo), C;
+    }(C, foo);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(C);
+    function C() {
+        return !function(instance, Constructor) {
+            if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+        }(this, C), _super.apply(this, arguments);
+    }
+    return C;
 } // error, cannot extend it though
 (foo1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classIsSubtypeOfBaseType/input.ts/es5.1.normal/output.js

@@ -44,25 +44,52 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base() {
     "use strict";
     _classCallCheck(this, Base);
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived() {
-        _classCallCheck(this, Derived);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        _classCallCheck(this, Derived1);
+        return _super.apply(this, arguments);
     }
-    return Derived;
+    return Derived1;
 }(Base);
 var Derived2 = /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2() {
         _classCallCheck(this, Derived2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Derived2;
 }(Base);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/classIsSubtypeOfBaseType/input.ts/es5.2.minified/output.js

@@ -16,32 +16,52 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var Base1 = function() {
     "use strict";
     _classCallCheck(this, Base1);
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived() {
-        return _classCallCheck(this, Derived), _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        return _classCallCheck(this, Derived1), _super.apply(this, arguments);
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1), Derived2 = function(Base) {
     "use strict";
+    _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2() {
-        return _classCallCheck(this, Derived2), _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        return _classCallCheck(this, Derived2), _super.apply(this, arguments);
     }
-    return _inherits(Derived2, Base), Derived2;
+    return Derived2;
 }(Base1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/constructorFunctionTypeIsAssignableToBaseType/input.ts/es5.1.normal/output.js

@@ -44,25 +44,52 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base() {
     "use strict";
     _classCallCheck(this, Base);
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived() {
-        _classCallCheck(this, Derived);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        _classCallCheck(this, Derived1);
+        return _super.apply(this, arguments);
     }
-    return Derived;
+    return Derived1;
 }(Base);
 var Derived2 = /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2() {
         _classCallCheck(this, Derived2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Derived2;
 }(Base);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/constructorFunctionTypeIsAssignableToBaseType/input.ts/es5.2.minified/output.js

@@ -16,32 +16,52 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var Base1 = function() {
     "use strict";
     _classCallCheck(this, Base1);
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived() {
-        return _classCallCheck(this, Derived), _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        return _classCallCheck(this, Derived1), _super.apply(this, arguments);
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1), Derived2 = function(Base) {
     "use strict";
+    _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2() {
-        return _classCallCheck(this, Derived2), _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        return _classCallCheck(this, Derived2), _super.apply(this, arguments);
     }
-    return _inherits(Derived2, Base), Derived2;
+    return Derived2;
 }(Base1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/constructorFunctionTypeIsAssignableToBaseType2/input.ts/es5.1.normal/output.js

@@ -44,25 +44,52 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base(x) {
     "use strict";
     _classCallCheck(this, Base);
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived(x) {
-        _classCallCheck(this, Derived);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived).call(this, x));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1(x) {
+        _classCallCheck(this, Derived1);
+        return _super.call(this, x);
     }
-    return Derived;
+    return Derived1;
 }(Base);
 var Derived2 = /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2(x) {
         _classCallCheck(this, Derived2);
-        var _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived2).call(this, x));
+        var _this = _super.call(this, x);
         return _possibleConstructorReturn(_this, 1);
     }
     return Derived2;

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/constructorFunctionTypeIsAssignableToBaseType2/input.ts/es5.2.minified/output.js

@@ -29,21 +29,45 @@ function _setPrototypeOf(o, p) {
 }
 var _typeof = function(obj) {
     return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function(x) {
+};
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var Base1 = function(x) {
     "use strict";
     _classCallCheck(this, Base1);
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived(x) {
-        return _classCallCheck(this, Derived), _possibleConstructorReturn(this, _getPrototypeOf(Derived).call(this, x));
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1(x) {
+        return _classCallCheck(this, Derived1), _super.call(this, x);
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1), Derived2 = function(Base) {
     "use strict";
+    _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2(x) {
-        _classCallCheck(this, Derived2);
-        var _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived2).call(this, x));
-        return _possibleConstructorReturn(_this, 1);
+        return _classCallCheck(this, Derived2), _possibleConstructorReturn(_super.call(this, x), 1);
     }
-    return _inherits(Derived2, Base), Derived2;
+    return Derived2;
 }(Base1);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/derivedTypeDoesNotRequireExtendsClause/input.ts/es5.1.normal/output.js

@@ -44,20 +44,46 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base() {
     "use strict";
     _classCallCheck(this, Base);
 };
-var Derived = function Derived() {
+var Derived1 = function Derived1() {
     "use strict";
-    _classCallCheck(this, Derived);
+    _classCallCheck(this, Derived1);
 };
 var Derived2 = /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(Derived2, Base);
+    var _super = _createSuper(Derived2);
     function Derived2() {
         _classCallCheck(this, Derived2);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Derived2;
 }(Base);

crates/swc/tests/tsc-references/classes/classDeclarations/classHeritageSpecification/derivedTypeDoesNotRequireExtendsClause/input.ts/es5.2.minified/output.js

@@ -14,19 +14,12 @@ function _setPrototypeOf(o, p) {
 var Base1 = function() {
     "use strict";
     _classCallCheck(this, Base1);
-}, Derived = function() {
+}, Derived1 = function() {
     "use strict";
-    _classCallCheck(this, Derived);
+    _classCallCheck(this, Derived1);
 }, Derived2 = function(Base) {
     "use strict";
-    function Derived2() {
-        var self, call, obj;
-        return _classCallCheck(this, Derived2), self = this, call = _getPrototypeOf(Derived2).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -35,5 +28,33 @@ var Base1 = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(Derived2, Base), Derived2;
+    }(Derived2, Base);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(Derived2);
+    function Derived2() {
+        return _classCallCheck(this, Derived2), _super.apply(this, arguments);
+    }
+    return Derived2;
 }(Base1);

crates/swc/tests/tsc-references/classes/classDeclarations/mergedInheritedClassInterface/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var BaseClass = /*#__PURE__*/ function() {
     "use strict";
     function BaseClass() {
@@ -75,9 +100,10 @@ var BaseClass = /*#__PURE__*/ function() {
 var Child = /*#__PURE__*/ function(BaseClass) {
     "use strict";
     _inherits(Child, BaseClass);
+    var _super = _createSuper(Child);
     function Child() {
         _classCallCheck(this, Child);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Child).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     _createClass(Child, [
         {
@@ -105,9 +131,10 @@ var ChildNoBaseClass = /*#__PURE__*/ function() {
 var Grandchild = /*#__PURE__*/ function(ChildNoBaseClass) {
     "use strict";
     _inherits(Grandchild, ChildNoBaseClass);
+    var _super = _createSuper(Grandchild);
     function Grandchild() {
         _classCallCheck(this, Grandchild);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Grandchild).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return Grandchild;
 }(ChildNoBaseClass);

crates/swc/tests/tsc-references/classes/classDeclarations/mergedInheritedClassInterface/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var child, grandchild, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, BaseClass = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var child, grandchild, BaseClass = function() {
     "use strict";
     function BaseClass() {
         _classCallCheck(this, BaseClass);
@@ -52,10 +68,12 @@ var child, grandchild, _typeof = function(obj) {
     ]), BaseClass;
 }(), Child = function(BaseClass) {
     "use strict";
+    _inherits(Child, BaseClass);
+    var _super = _createSuper(Child);
     function Child() {
-        return _classCallCheck(this, Child), _possibleConstructorReturn(this, _getPrototypeOf(Child).apply(this, arguments));
+        return _classCallCheck(this, Child), _super.apply(this, arguments);
     }
-    return _inherits(Child, BaseClass), _createClass(Child, [
+    return _createClass(Child, [
         {
             key: "method",
             value: function() {
@@ -76,9 +94,11 @@ var child, grandchild, _typeof = function(obj) {
     ]), ChildNoBaseClass;
 }(), Grandchild = function(ChildNoBaseClass) {
     "use strict";
+    _inherits(Grandchild, ChildNoBaseClass);
+    var _super = _createSuper(Grandchild);
     function Grandchild() {
-        return _classCallCheck(this, Grandchild), _possibleConstructorReturn(this, _getPrototypeOf(Grandchild).apply(this, arguments));
+        return _classCallCheck(this, Grandchild), _super.apply(this, arguments);
     }
-    return _inherits(Grandchild, ChildNoBaseClass), Grandchild;
+    return Grandchild;
 }(ChildNoBaseClass);
 child.required, child.optional, child.additional, child.baseNumber, child.classNumber, child.baseMethod(), child.method(), grandchild.required, grandchild.optional, grandchild.additional2, grandchild.classString, grandchild.method2();

crates/swc/tests/tsc-references/classes/classExpressions/classExpression2/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var D = function D() {
     "use strict";
     _classCallCheck(this, D);
@@ -51,9 +76,10 @@ var D = function D() {
 var v = /*#__PURE__*/ function(D) {
     "use strict";
     _inherits(C, D);
+    var _super = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return C;
 }(D);

crates/swc/tests/tsc-references/classes/classExpressions/classExpression2/input.ts/es5.2.minified/output.js

@@ -17,13 +17,6 @@ var D1 = function() {
 };
 !function(D) {
     "use strict";
-    function C() {
-        var self, call, obj;
-        return _classCallCheck(this, C), self = this, call = _getPrototypeOf(C).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
     !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
@@ -34,4 +27,31 @@ var D1 = function() {
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
     }(C, D);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(C);
+    function C() {
+        return _classCallCheck(this, C), _super.apply(this, arguments);
+    }
 }(D1);

crates/swc/tests/tsc-references/classes/classExpressions/classExpression3/input.ts/es5.1.normal/output.js

@@ -44,13 +44,39 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(_class, _super);
+    var _super1 = _createSuper(_class);
     function _class() {
         _classCallCheck(this, _class);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+        _this = _super1.apply(this, arguments);
         _this.c = 3;
         return _this;
     }
@@ -58,10 +84,11 @@ var C = /*#__PURE__*/ function(_super) {
 }(/*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(_class, _super);
+    var _super2 = _createSuper(_class);
     function _class() {
         _classCallCheck(this, _class);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+        _this = _super2.apply(this, arguments);
         _this.b = 2;
         return _this;
     }

crates/swc/tests/tsc-references/classes/classExpressions/classExpression3/input.ts/es5.2.minified/output.js

@@ -16,33 +16,53 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, c = new (function(_super) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var c = new (function(_super) {
     "use strict";
+    _inherits(_class, _super);
+    var _super1 = _createSuper(_class);
     function _class() {
         var _this;
-        return _classCallCheck(this, _class), _this = _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments)), _this.c = 3, _this;
+        return _classCallCheck(this, _class), _this = _super1.apply(this, arguments), _this.c = 3, _this;
     }
-    return _inherits(_class, _super), _class;
+    return _class;
 }(function(_super) {
     "use strict";
+    _inherits(_class, _super);
+    var _super2 = _createSuper(_class);
     function _class() {
         var _this;
-        return _classCallCheck(this, _class), _this = _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments)), _this.b = 2, _this;
+        return _classCallCheck(this, _class), _this = _super2.apply(this, arguments), _this.b = 2, _this;
     }
-    return _inherits(_class, _super), _class;
+    return _class;
 }(function _class() {
     "use strict";
     _classCallCheck(this, _class), this.a = 1;

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterBindingPattern.2/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var _class, _class1;
 var C = function C() {
     "use strict";
@@ -53,9 +78,10 @@ var C = function C() {
     var tmp = param[/*#__PURE__*/ (_class = function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class.x = 1, _class).x], b = tmp === void 0 ? "" : tmp;
@@ -66,9 +92,10 @@ var x = "";
     var tmp = param[/*#__PURE__*/ (_class1 = function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class1.x = 1, _class1).x], b = tmp === void 0 ? "" : tmp, d = param1 === void 0 ? x : param1;

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterBindingPattern.2/input.ts/es5.2.minified/output.js

@@ -16,37 +16,57 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _class, _class1, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var _class, _class1, C = function() {
     "use strict";
     _classCallCheck(this, C);
 };
 !function(param) {
     (void 0)[((_class = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C)).x = 1, _class).x];
 }(), (function(param, param1) {
     (void 0)[((_class1 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C)).x = 1, _class1).x];
 })();

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterBindingPattern.3/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var _class, _class1;
 var C = function C() {
     "use strict";
@@ -53,9 +78,10 @@ var C = function C() {
     var tmp = param[/*#__PURE__*/ (_class = function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class.x = 1, _class).x], b = tmp === void 0 ? "" : tmp;
@@ -66,9 +92,10 @@ var x = "";
     var tmp = param[/*#__PURE__*/ (_class1 = function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class1.x = 1, _class1).x], b = tmp === void 0 ? "" : tmp, d = param1 === void 0 ? x : param1;

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterBindingPattern.3/input.ts/es5.2.minified/output.js

@@ -16,37 +16,57 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _class, _class1, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var _class, _class1, C = function() {
     "use strict";
     _classCallCheck(this, C);
 };
 !function(param) {
     (void 0)[((_class = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C)).x = 1, _class).x];
 }(), (function(param, param1) {
     (void 0)[((_class1 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C)).x = 1, _class1).x];
 })();

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterInitializer.2/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var _class2, _class1;
 var C = function C() {
     "use strict";
@@ -53,9 +78,10 @@ var C = function C() {
     var b = param === void 0 ? (_class2 = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class2.x = 1, _class2) : param;
@@ -66,9 +92,10 @@ var x = "";
     var b = param === void 0 ? (_class1 = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class1.x = 1, _class1) : param, d = param1 === void 0 ? x : param1;

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterInitializer.2/input.ts/es5.2.minified/output.js

@@ -16,37 +16,57 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _class2, _class1, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var _class2, _class1, C1 = function() {
     "use strict";
     _classCallCheck(this, C1);
 };
 !function(param) {
     (_class2 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C1)).x = 1;
 }(), (function(param, param1) {
     (_class1 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C1)).x = 1;
 })();

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterInitializer.3/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var _class2, _class1;
 var C = function C() {
     "use strict";
@@ -53,9 +78,10 @@ var C = function C() {
     var b = param === void 0 ? (_class2 = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class2.x = 1, _class2) : param;
@@ -66,9 +92,10 @@ var x = "";
     var b = param === void 0 ? (_class1 = /*#__PURE__*/ function(C) {
         "use strict";
         _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     }(C), _class1.x = 1, _class1) : param, d = param1 === void 0 ? x : param1;

crates/swc/tests/tsc-references/classes/classExpressions/classWithStaticFieldInParameterInitializer.3/input.ts/es5.2.minified/output.js

@@ -16,37 +16,57 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _class2, _class1, _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, C1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var _class2, _class1, C1 = function() {
     "use strict";
     _classCallCheck(this, C1);
 };
 !function(param) {
     (_class2 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C1)).x = 1;
 }(), (function(param, param1) {
     (_class1 = (function(C) {
         "use strict";
+        _inherits(_class, C);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, C), _class;
+        return _class;
     })(C1)).x = 1;
 })();

crates/swc/tests/tsc-references/classes/classExpressions/extendClassExpressionFromModule/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var x1 = function x1() {
     "use strict";
     _classCallCheck(this, x1);
@@ -55,9 +80,10 @@ var x1 = foo1;
 var y = /*#__PURE__*/ function(x) {
     "use strict";
     _inherits(y, x);
+    var _super = _createSuper(y);
     function y() {
         _classCallCheck(this, y);
-        return _possibleConstructorReturn(this, _getPrototypeOf(y).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return y;
 }(x1);

crates/swc/tests/tsc-references/classes/classExpressions/extendClassExpressionFromModule/input.ts/es5.2.minified/output.js

@@ -18,14 +18,7 @@ var x1 = function() {
 module.exports = x1;
 var x1 = require("./foo1"), y = function(x) {
     "use strict";
-    function y() {
-        var self, call, obj;
-        return _classCallCheck(this, y), self = this, call = _getPrototypeOf(y).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -34,6 +27,34 @@ var x1 = require("./foo1"), y = function(x) {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(y, x), y;
+    }(y, x);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(y);
+    function y() {
+        return _classCallCheck(this, y), _super.apply(this, arguments);
+    }
+    return y;
 }(x1);
 export { };

crates/swc/tests/tsc-references/classes/classExpressions/genericClassExpressionInFunction/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A = function A() {
     "use strict";
     _classCallCheck(this, A);
@@ -53,9 +78,10 @@ function B1() {
     return /*#__PURE__*/ (function(A) {
         "use strict";
         _inherits(_class, A);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     })(A);
@@ -65,9 +91,10 @@ var B2 = function B2() {
     _classCallCheck(this, B2);
     this.anon = /*#__PURE__*/ (function(A) {
         _inherits(_class, A);
+        var _super = _createSuper(_class);
         function _class() {
             _classCallCheck(this, _class);
-            return _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return _class;
     })(A);
@@ -76,9 +103,10 @@ function B3() {
     return /*#__PURE__*/ (function(A) {
         "use strict";
         _inherits(Inner, A);
+        var _super = _createSuper(Inner);
         function Inner() {
             _classCallCheck(this, Inner);
-            return _possibleConstructorReturn(this, _getPrototypeOf(Inner).apply(this, arguments));
+            return _super.apply(this, arguments);
         }
         return Inner;
     })(A);
@@ -87,18 +115,20 @@ var K = // extends can call B
 /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(K, _super);
+    var _super1 = _createSuper(K);
     function K() {
         _classCallCheck(this, K);
-        return _possibleConstructorReturn(this, _getPrototypeOf(K).apply(this, arguments));
+        return _super1.apply(this, arguments);
     }
     return K;
 }(B1());
 var C = /*#__PURE__*/ function(_super) {
     "use strict";
     _inherits(C, _super);
+    var _super2 = _createSuper(C);
     function C() {
         _classCallCheck(this, C);
-        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _super2.apply(this, arguments);
     }
     return C;
 }(new B2().anon);
@@ -106,9 +136,10 @@ var b3Number1 = B3();
 var S = /*#__PURE__*/ function(b3Number) {
     "use strict";
     _inherits(S, b3Number);
+    var _super = _createSuper(S);
     function S() {
         _classCallCheck(this, S);
-        return _possibleConstructorReturn(this, _getPrototypeOf(S).apply(this, arguments));
+        return _super.apply(this, arguments);
     }
     return S;
 }(b3Number1);

crates/swc/tests/tsc-references/classes/classExpressions/genericClassExpressionInFunction/input.ts/es5.2.minified/output.js

@@ -16,63 +16,91 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     _classCallCheck(this, A1);
 }, B2 = function() {
     "use strict";
     _classCallCheck(this, B2), this.anon = (function(A) {
+        _inherits(_class, A);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, A), _class;
+        return _class;
     })(A1);
 }, K = function(_super) {
     "use strict";
+    _inherits(K, _super);
+    var _super1 = _createSuper(K);
     function K() {
-        return _classCallCheck(this, K), _possibleConstructorReturn(this, _getPrototypeOf(K).apply(this, arguments));
+        return _classCallCheck(this, K), _super1.apply(this, arguments);
     }
-    return _inherits(K, _super), K;
+    return K;
 }(function() {
     return (function(A) {
         "use strict";
+        _inherits(_class, A);
+        var _super = _createSuper(_class);
         function _class() {
-            return _classCallCheck(this, _class), _possibleConstructorReturn(this, _getPrototypeOf(_class).apply(this, arguments));
+            return _classCallCheck(this, _class), _super.apply(this, arguments);
         }
-        return _inherits(_class, A), _class;
+        return _class;
     })(A1);
 }()), C = function(_super) {
     "use strict";
+    _inherits(C, _super);
+    var _super2 = _createSuper(C);
     function C() {
-        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+        return _classCallCheck(this, C), _super2.apply(this, arguments);
     }
-    return _inherits(C, _super), C;
+    return C;
 }(new B2().anon), S = function(b3Number) {
     "use strict";
+    _inherits(S, b3Number);
+    var _super = _createSuper(S);
     function S() {
-        return _classCallCheck(this, S), _possibleConstructorReturn(this, _getPrototypeOf(S).apply(this, arguments));
+        return _classCallCheck(this, S), _super.apply(this, arguments);
     }
-    return _inherits(S, b3Number), S;
+    return S;
 }(function() {
     return (function(A) {
         "use strict";
+        _inherits(Inner, A);
+        var _super = _createSuper(Inner);
         function Inner() {
-            return _classCallCheck(this, Inner), _possibleConstructorReturn(this, _getPrototypeOf(Inner).apply(this, arguments));
+            return _classCallCheck(this, Inner), _super.apply(this, arguments);
         }
-        return _inherits(Inner, A), Inner;
+        return Inner;
     })(A1);
 }()), c = new C(), k = new K(), s = new S();
 c.genericVar = 12, k.genericVar = 12, s.genericVar = 12;

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor/input.ts/es5.1.normal/output.js

@@ -44,27 +44,53 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base(x) {
     "use strict";
     _classCallCheck(this, Base);
     this.a = 1;
     this.a = x;
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived() {
-        _classCallCheck(this, Derived);
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        _classCallCheck(this, Derived1);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 1;
         _this.y = 'hello';
         return _this;
     }
-    return Derived;
+    return Derived1;
 }(Base);
-var r = new Derived(); // error
-var r2 = new Derived(1);
+var r = new Derived1(); // error
+var r2 = new Derived1(1);
 var Base2 = function Base2(x) {
     "use strict";
     _classCallCheck(this, Base2);
@@ -73,10 +99,11 @@ var Base2 = function Base2(x) {
 var D = /*#__PURE__*/ function(Base2) {
     "use strict";
     _inherits(D, Base2);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 2;
         _this.y = null;
         return _this;

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor/input.ts/es5.2.minified/output.js

@@ -16,40 +16,60 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function(x) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var Base1 = function(x) {
     "use strict";
     _classCallCheck(this, Base1), this.a = 1, this.a = x;
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived() {
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
         var _this;
-        return _classCallCheck(this, Derived), _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments)), _this.x = 1, _this.y = "hello", _this;
+        return _classCallCheck(this, Derived1), _this = _super.apply(this, arguments), _this.x = 1, _this.y = "hello", _this;
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1);
-new Derived(), new Derived(1);
+new Derived1(), new Derived1(1);
 var Base21 = function(x) {
     "use strict";
     _classCallCheck(this, Base21), this.a = x;
 }, D = function(Base2) {
     "use strict";
+    _inherits(D, Base2);
+    var _super = _createSuper(D);
     function D() {
         var _this;
-        return _classCallCheck(this, D), _this = _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments)), _this.x = 2, _this.y = null, _this;
+        return _classCallCheck(this, D), _this = _super.apply(this, arguments), _this.x = 2, _this.y = null, _this;
     }
-    return _inherits(D, Base2), D;
+    return D;
 }(Base21);
 new D(), new D(new Date());

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor2/input.ts/es5.1.normal/output.js

@@ -44,29 +44,55 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base(x) {
     "use strict";
     _classCallCheck(this, Base);
     this.a = 1;
     this.a = x;
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived() {
-        _classCallCheck(this, Derived);
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        _classCallCheck(this, Derived1);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 1;
         _this.y = 'hello';
         return _this;
     }
-    return Derived;
+    return Derived1;
 }(Base);
-var r = new Derived(); // error
-var r2 = new Derived(1);
-var r3 = new Derived(1, 2);
-var r4 = new Derived(1, 2, 3);
+var r = new Derived1(); // error
+var r2 = new Derived1(1);
+var r3 = new Derived1(1, 2);
+var r4 = new Derived1(1, 2, 3);
 var Base2 = function Base2(x) {
     "use strict";
     _classCallCheck(this, Base2);
@@ -75,10 +101,11 @@ var Base2 = function Base2(x) {
 var D = /*#__PURE__*/ function(Base2) {
     "use strict";
     _inherits(D, Base2);
+    var _super = _createSuper(D);
     function D() {
         _classCallCheck(this, D);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 2;
         _this.y = null;
         return _this;

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor2/input.ts/es5.2.minified/output.js

@@ -16,40 +16,60 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function(x) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var Base1 = function(x) {
     "use strict";
     _classCallCheck(this, Base1), this.a = 1, this.a = x;
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived() {
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
         var _this;
-        return _classCallCheck(this, Derived), _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments)), _this.x = 1, _this.y = "hello", _this;
+        return _classCallCheck(this, Derived1), _this = _super.apply(this, arguments), _this.x = 1, _this.y = "hello", _this;
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1);
-new Derived(), new Derived(1), new Derived(1, 2), new Derived(1, 2, 3);
+new Derived1(), new Derived1(1), new Derived1(1, 2), new Derived1(1, 2, 3);
 var Base21 = function(x) {
     "use strict";
     _classCallCheck(this, Base21), this.a = x;
 }, D = function(Base2) {
     "use strict";
+    _inherits(D, Base2);
+    var _super = _createSuper(D);
     function D() {
         var _this;
-        return _classCallCheck(this, D), _this = _possibleConstructorReturn(this, _getPrototypeOf(D).apply(this, arguments)), _this.x = 2, _this.y = null, _this;
+        return _classCallCheck(this, D), _this = _super.apply(this, arguments), _this.x = 2, _this.y = null, _this;
     }
-    return _inherits(D, Base2), D;
+    return D;
 }(Base21);
 new D(), new D(new Date()), new D(new Date(), new Date()), new D(new Date(), new Date(), new Date());

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor3/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base(x) {
     "use strict";
     _classCallCheck(this, Base);
@@ -51,35 +76,37 @@ var Base = function Base(x) {
     this.a = 1;
     this.a = x;
 };
-var Derived = /*#__PURE__*/ function(Base) {
+var Derived1 = /*#__PURE__*/ function(Base) {
     "use strict";
-    _inherits(Derived, Base);
-    function Derived(y, z) {
-        _classCallCheck(this, Derived);
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1(y, z) {
+        _classCallCheck(this, Derived1);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).call(this, 2));
+        _this = _super.call(this, 2);
         _this.b = '';
         _this.b = y;
         return _this;
     }
-    return Derived;
+    return Derived1;
 }(Base);
 var Derived2 = /*#__PURE__*/ function(Derived) {
     "use strict";
     _inherits(Derived2, Derived);
+    var _super = _createSuper(Derived2);
     function Derived2() {
         _classCallCheck(this, Derived2);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 1;
         _this.y = 'hello';
         return _this;
     }
     return Derived2;
-}(Derived);
-var r = new Derived(); // error
+}(Derived1);
+var r = new Derived1(); // error
 var r2 = new Derived2(1); // error
-var r3 = new Derived('', '');
+var r3 = new Derived1('', '');
 var Base2 = function Base2(x) {
     "use strict";
     _classCallCheck(this, Base2);
@@ -88,10 +115,11 @@ var Base2 = function Base2(x) {
 var D = /*#__PURE__*/ function(Base) {
     "use strict";
     _inherits(D, Base);
+    var _super = _createSuper(D);
     function D(y, z) {
         _classCallCheck(this, D);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D).call(this, 2));
+        _this = _super.call(this, 2);
         _this.b = null;
         _this.b = y;
         return _this;
@@ -101,10 +129,11 @@ var D = /*#__PURE__*/ function(Base) {
 var D2 = /*#__PURE__*/ function(D) {
     "use strict";
     _inherits(D2, D);
+    var _super = _createSuper(D2);
     function D2() {
         _classCallCheck(this, D2);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments));
+        _this = _super.apply(this, arguments);
         _this.x = 2;
         _this.y = null;
         return _this;

crates/swc/tests/tsc-references/classes/constructorDeclarations/automaticConstructors/derivedClassWithoutExplicitConstructor3/input.ts/es5.2.minified/output.js

@@ -16,54 +16,78 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, Base1 = function(x) {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var Base1 = function(x) {
     "use strict";
     _classCallCheck(this, Base1), this.a = 1, this.a = x;
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived(y, z) {
+    _inherits(Derived1, Base);
+    var _super = _createSuper(Derived1);
+    function Derived1(y, z) {
         var _this;
-        return _classCallCheck(this, Derived), (_this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).call(this, 2))).b = "", _this.b = y, _this;
+        return _classCallCheck(this, Derived1), (_this = _super.call(this, 2)).b = "", _this.b = y, _this;
     }
-    return _inherits(Derived, Base), Derived;
+    return Derived1;
 }(Base1), Derived2 = function(Derived) {
     "use strict";
+    _inherits(Derived2, Derived);
+    var _super = _createSuper(Derived2);
     function Derived2() {
         var _this;
-        return _classCallCheck(this, Derived2), _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments)), _this.x = 1, _this.y = "hello", _this;
+        return _classCallCheck(this, Derived2), _this = _super.apply(this, arguments), _this.x = 1, _this.y = "hello", _this;
     }
-    return _inherits(Derived2, Derived), Derived2;
-}(Derived);
-new Derived(), new Derived2(1), new Derived("", "");
+    return Derived2;
+}(Derived1);
+new Derived1(), new Derived2(1), new Derived1("", "");
 var Base2 = function(x) {
     "use strict";
     _classCallCheck(this, Base2), this.a = x;
 }, D = function(Base) {
     "use strict";
+    _inherits(D, Base);
+    var _super = _createSuper(D);
     function D(y, z) {
         var _this;
-        return _classCallCheck(this, D), (_this = _possibleConstructorReturn(this, _getPrototypeOf(D).call(this, 2))).b = null, _this.b = y, _this;
+        return _classCallCheck(this, D), (_this = _super.call(this, 2)).b = null, _this.b = y, _this;
     }
-    return _inherits(D, Base), D;
+    return D;
 }(Base1), D2 = function(D) {
     "use strict";
+    _inherits(D2, D);
+    var _super = _createSuper(D2);
     function D2() {
         var _this;
-        return _classCallCheck(this, D2), _this = _possibleConstructorReturn(this, _getPrototypeOf(D2).apply(this, arguments)), _this.x = 2, _this.y = null, _this;
+        return _classCallCheck(this, D2), _this = _super.apply(this, arguments), _this.x = 2, _this.y = null, _this;
     }
-    return _inherits(D2, D), D2;
+    return D2;
 }(D);
 new D2(), new D2(new Date()), new D2(new Date(), new Date());

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility2/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var BaseA = // @declaration: true
 /*#__PURE__*/ function() {
     "use strict";
@@ -117,10 +142,11 @@ var BaseC = /*#__PURE__*/ function() {
 var DerivedA = /*#__PURE__*/ function(BaseA1) {
     "use strict";
     _inherits(DerivedA, BaseA1);
+    var _super = _createSuper(DerivedA);
     function DerivedA(x) {
         _classCallCheck(this, DerivedA);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedA).call(this, x));
+        _this = _super.call(this, x);
         _this.x = x;
         return _this;
     }
@@ -150,10 +176,11 @@ var DerivedA = /*#__PURE__*/ function(BaseA1) {
 var DerivedB = /*#__PURE__*/ function(BaseB1) {
     "use strict";
     _inherits(DerivedB, BaseB1);
+    var _super = _createSuper(DerivedB);
     function DerivedB(x) {
         _classCallCheck(this, DerivedB);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedB).call(this, x));
+        _this = _super.call(this, x);
         _this.x = x;
         return _this;
     }
@@ -183,10 +210,11 @@ var DerivedB = /*#__PURE__*/ function(BaseB1) {
 var DerivedC = /*#__PURE__*/ function(BaseC1) {
     "use strict";
     _inherits(DerivedC, BaseC1);
+    var _super = _createSuper(DerivedC);
     function DerivedC(x) {
         _classCallCheck(this, DerivedC);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedC).call(this, x));
+        _this = _super.call(this, x);
         _this.x = x;
         return _this;
     }

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility2/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, BaseA = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var BaseA = function() {
     "use strict";
     function BaseA(x) {
         _classCallCheck(this, BaseA), this.x = x;
@@ -86,11 +102,13 @@ var _typeof = function(obj) {
     ]), BaseC;
 }(), DerivedA = function(BaseA1) {
     "use strict";
+    _inherits(DerivedA, BaseA1);
+    var _super = _createSuper(DerivedA);
     function DerivedA(x) {
         var _this;
-        return _classCallCheck(this, DerivedA), (_this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedA).call(this, x))).x = x, _this;
+        return _classCallCheck(this, DerivedA), (_this = _super.call(this, x)).x = x, _this;
     }
-    return _inherits(DerivedA, BaseA1), _createClass(DerivedA, [
+    return _createClass(DerivedA, [
         {
             key: "createInstance",
             value: function() {
@@ -113,11 +131,13 @@ var _typeof = function(obj) {
     ]), DerivedA;
 }(BaseA), DerivedB = function(BaseB1) {
     "use strict";
+    _inherits(DerivedB, BaseB1);
+    var _super = _createSuper(DerivedB);
     function DerivedB(x) {
         var _this;
-        return _classCallCheck(this, DerivedB), (_this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedB).call(this, x))).x = x, _this;
+        return _classCallCheck(this, DerivedB), (_this = _super.call(this, x)).x = x, _this;
     }
-    return _inherits(DerivedB, BaseB1), _createClass(DerivedB, [
+    return _createClass(DerivedB, [
         {
             key: "createInstance",
             value: function() {
@@ -140,11 +160,13 @@ var _typeof = function(obj) {
     ]), DerivedB;
 }(BaseB), DerivedC = function(BaseC1) {
     "use strict";
+    _inherits(DerivedC, BaseC1);
+    var _super = _createSuper(DerivedC);
     function DerivedC(x) {
         var _this;
-        return _classCallCheck(this, DerivedC), (_this = _possibleConstructorReturn(this, _getPrototypeOf(DerivedC).call(this, x))).x = x, _this;
+        return _classCallCheck(this, DerivedC), (_this = _super.call(this, x)).x = x, _this;
     }
-    return _inherits(DerivedC, BaseC1), _createClass(DerivedC, [
+    return _createClass(DerivedC, [
         {
             key: "createInstance",
             value: function() {

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility4/input.ts/es5.1.normal/output.js

@@ -58,6 +58,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var A1 = // @declaration: true
 /*#__PURE__*/ function() {
     "use strict";
@@ -84,9 +109,10 @@ var A1 = // @declaration: true
                 }();
                 var C = /*#__PURE__*/ function(A) {
                     _inherits(C, A);
+                    var _super = _createSuper(C);
                     function C() {
                         _classCallCheck(this, C);
-                        return _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+                        return _super.apply(this, arguments);
                     }
                     return C;
                 }(A1);
@@ -120,9 +146,10 @@ var D1 = /*#__PURE__*/ function() {
                 }();
                 var F = /*#__PURE__*/ function(D) {
                     _inherits(F, D);
+                    var _super = _createSuper(F);
                     function F() {
                         _classCallCheck(this, F);
-                        return _possibleConstructorReturn(this, _getPrototypeOf(F).apply(this, arguments));
+                        return _super.apply(this, arguments);
                     }
                     return F;
                 }(D1);

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility4/input.ts/es5.2.minified/output.js

@@ -25,20 +25,36 @@ function _inherits(subClass, superClass) {
         }
     }), superClass && _setPrototypeOf(subClass, superClass);
 }
-function _possibleConstructorReturn(self, call) {
-    return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
-        if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        return self;
-    })(self);
-}
 function _setPrototypeOf(o, p) {
     return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
         return o.__proto__ = p, o;
     }, _setPrototypeOf(o, p);
 }
-var _typeof = function(obj) {
-    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}, A1 = function() {
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = function() {
+        if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+        if (Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+        } catch (e) {
+            return !1;
+        }
+    }();
+    return function() {
+        var obj, self, call, result, Super = _getPrototypeOf(Derived);
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else result = Super.apply(this, arguments);
+        return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            return self;
+        })(self);
+    };
+}
+var A1 = function() {
     "use strict";
     function A1() {
         _classCallCheck(this, A1);
@@ -60,10 +76,12 @@ var _typeof = function(obj) {
                         }
                     ]), B;
                 }(), C = function(A) {
+                    _inherits(C, A);
+                    var _super = _createSuper(C);
                     function C() {
-                        return _classCallCheck(this, C), _possibleConstructorReturn(this, _getPrototypeOf(C).apply(this, arguments));
+                        return _classCallCheck(this, C), _super.apply(this, arguments);
                     }
-                    return _inherits(C, A), C;
+                    return C;
                 }(A1);
             }
         }
@@ -90,10 +108,12 @@ var _typeof = function(obj) {
                         }
                     ]), E;
                 }(), F = function(D) {
+                    _inherits(F, D);
+                    var _super = _createSuper(F);
                     function F() {
-                        return _classCallCheck(this, F), _possibleConstructorReturn(this, _getPrototypeOf(F).apply(this, arguments));
+                        return _classCallCheck(this, F), _super.apply(this, arguments);
                     }
-                    return _inherits(F, D), F;
+                    return F;
                 }(D1);
             }
         }

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility5/input.ts/es5.1.normal/output.js

@@ -58,18 +58,44 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var Base = function Base() {
     "use strict";
     _classCallCheck(this, Base);
 };
-var Derived = /*#__PURE__*/ function(Base1) {
+var Derived1 = /*#__PURE__*/ function(Base1) {
     "use strict";
-    _inherits(Derived, Base1);
-    function Derived() {
-        _classCallCheck(this, Derived);
-        return _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
+    _inherits(Derived1, Base1);
+    var _super = _createSuper(Derived1);
+    function Derived1() {
+        _classCallCheck(this, Derived1);
+        return _super.apply(this, arguments);
     }
-    _createClass(Derived, null, [
+    _createClass(Derived1, null, [
         {
             key: "make",
             value: function make() {
@@ -77,7 +103,7 @@ var Derived = /*#__PURE__*/ function(Base1) {
             } // ok
         }
     ]);
-    return Derived;
+    return Derived1;
 }(Base);
 var Unrelated = /*#__PURE__*/ function() {
     "use strict";

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorAccessibility5/input.ts/es5.2.minified/output.js

@@ -23,16 +23,9 @@ function _setPrototypeOf(o, p) {
 var Base1 = function() {
     "use strict";
     _classCallCheck(this, Base1);
-}, Derived = function(Base) {
+}, Derived1 = function(Base) {
     "use strict";
-    function Derived() {
-        var self, call, obj;
-        return _classCallCheck(this, Derived), self = this, call = _getPrototypeOf(Derived).apply(this, arguments), call && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
-            if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-            return self;
-        })(self);
-    }
-    return !function(subClass, superClass) {
+    !function(subClass, superClass) {
         if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
         subClass.prototype = Object.create(superClass && superClass.prototype, {
             constructor: {
@@ -41,14 +34,42 @@ var Base1 = function() {
                 configurable: !0
             }
         }), superClass && _setPrototypeOf(subClass, superClass);
-    }(Derived, Base), _createClass(Derived, null, [
+    }(Derived1, Base);
+    var _super = function(Derived) {
+        var hasNativeReflectConstruct = function() {
+            if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
+            if (Reflect.construct.sham) return !1;
+            if ("function" == typeof Proxy) return !0;
+            try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+            } catch (e) {
+                return !1;
+            }
+        }();
+        return function() {
+            var obj, self, call, result, Super = _getPrototypeOf(Derived);
+            if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+            } else result = Super.apply(this, arguments);
+            return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
+                if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                return self;
+            })(self);
+        };
+    }(Derived1);
+    function Derived1() {
+        return _classCallCheck(this, Derived1), _super.apply(this, arguments);
+    }
+    return _createClass(Derived1, null, [
         {
             key: "make",
             value: function() {
                 new Base1();
             }
         }
-    ]), Derived;
+    ]), Derived1;
 }(Base1), Unrelated = function() {
     "use strict";
     function Unrelated() {

crates/swc/tests/tsc-references/classes/constructorDeclarations/classConstructorParametersAccessibility/input.ts/es5.1.normal/output.js

@@ -44,6 +44,31 @@ function _setPrototypeOf(o, p) {
 var _typeof = function(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
 var C1 = function C1(x) {
     "use strict";
     _classCallCheck(this, C1);
@@ -68,15 +93,16 @@ var C3 = function C3(p) {
 var c3;
 c3.p // protected, error
 ;
-var Derived = /*#__PURE__*/ function(C3) {
+var Derived1 = /*#__PURE__*/ function(C3) {
     "use strict";
-    _inherits(Derived, C3);
-    function Derived(p) {
-        _classCallCheck(this, Derived);
+    _inherits(Derived1, C3);
+    var _super = _createSuper(Derived1);
+    function Derived1(p) {
+        _classCallCheck(this, Derived1);
         var _this;
-        _this = _possibleConstructorReturn(this, _getPrototypeOf(Derived).call(this, p));
+        _this = _super.call(this, p);
         _this.p; // OK
         return _this;
     }
-    return Derived;
+    return Derived1;
 }(C3);