Enable external-helpers by default in tests (#12911)

Co-authored-by: Huáng Jùnliàng <jlhwung@gmail.com>
Co-authored-by: Babel Bot <babel-bot@users.noreply.github.com>

packages/babel-plugin-transform-classes/test/fixtures/assumption-constantSuper/accessing-super-property-optional-chain/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     ["proposal-optional-chaining", { "loose": true }],
     "transform-function-name",
     ["transform-classes", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/assumption-constantSuper/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     "transform-classes",
     ["transform-spread", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/assumption-noCallClass/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     "transform-classes",
     ["transform-spread", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/assumption-setClassMethods/method-return-type-annotation/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     ["transform-classes", { "loose": true }],
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/assumption-setClassMethods/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     "transform-classes",
     ["transform-spread", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     "transform-classes",
     ["transform-spread", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/loose/output.js

@@ -1,25 +1,11 @@
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
-
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, 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 _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 var List = /*#__PURE__*/function (_Array) {
   "use strict";
 
-  _inheritsLoose(List, _Array);
+  babelHelpers.inheritsLoose(List, _Array);
 
   function List() {
     return _Array.apply(this, arguments) || this;
   }
 
   return List;
-}( /*#__PURE__*/_wrapNativeSuper(Array));
+}( /*#__PURE__*/babelHelpers.wrapNativeSuper(Array));

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/shadowed/options.json

@@ -1,3 +1,3 @@
 {
-  "plugins": ["transform-classes", "external-helpers"]
+  "plugins": ["transform-classes"]
 }

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/shadowed/output.js

@@ -1,7 +1,3 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 let Array = function Array() {
   "use strict";
 
@@ -13,7 +9,7 @@ let List = /*#__PURE__*/function (_Array) {
 
   babelHelpers.inherits(List, _Array);
 
-  var _super = _createSuper(List);
+  var _super = babelHelpers.createSuper(List);
 
   function List() {
     babelHelpers.classCallCheck(this, List);

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/spec/output.js

@@ -1,37 +1,14 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
-
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, 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 _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 var List = /*#__PURE__*/function (_Array) {
   "use strict";
 
-  _inherits(List, _Array);
+  babelHelpers.inherits(List, _Array);
 
-  var _super = _createSuper(List);
+  var _super = babelHelpers.createSuper(List);
 
   function List() {
-    _classCallCheck(this, List);
-
+    babelHelpers.classCallCheck(this, List);
     return _super.apply(this, arguments);
   }
 
   return List;
-}( /*#__PURE__*/_wrapNativeSuper(Array));
+}( /*#__PURE__*/babelHelpers.wrapNativeSuper(Array));

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/wrap-native-super/options.json

@@ -1,7 +1,3 @@
 {
-  "plugins": [
-    "transform-classes",
-    "transform-block-scoping",
-    "external-helpers"
-  ]
+  "plugins": ["transform-classes", "transform-block-scoping"]
 }

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/call-semantics-data-defined-on-parent/output.js

@@ -1,9 +1,5 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
@@ -19,7 +15,7 @@ let Base = /*#__PURE__*/function () {
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/call-semantics-getter-defined-on-parent/output.js

@@ -1,17 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       // This is incorrect according to the spec,
@@ -24,12 +16,11 @@ let Base = /*#__PURE__*/function () {
       };
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/call-semantics-not-defined-on-parent/output.js

@@ -1,13 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/call-semantics-setter-defined-on-parent/output.js

@@ -1,28 +1,19 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       throw new Error("gobbledygook");
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/get-semantics-data-defined-on-parent/output.js

@@ -1,15 +1,11 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 Base.prototype.test = 1;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/get-semantics-getter-defined-on-parent/output.js

@@ -1,17 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       // This is incorrect according to the spec,
@@ -20,12 +12,11 @@ let Base = /*#__PURE__*/function () {
       return 1;
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/get-semantics-not-defined-on-parent/output.js

@@ -1,13 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/get-semantics-setter-defined-on-parent/output.js

@@ -1,28 +1,19 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       throw new Error("called");
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/memoized-assign/output.js

@@ -1,9 +1,5 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 Object.defineProperty(Base.prototype, 0, {
@@ -25,7 +21,7 @@ const proper = {
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/memoized-update/output.js

@@ -1,9 +1,5 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 Object.defineProperty(Base.prototype, 0, {
@@ -25,7 +21,7 @@ const proper = {
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-data-defined-on-parent/output.js

@@ -1,9 +1,5 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 Object.defineProperty(Base.prototype, 'test', {
@@ -13,7 +9,7 @@ Object.defineProperty(Base.prototype, 'test', {
 });
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-getter-defined-on-parent/output.js

@@ -1,33 +1,24 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let called = false;
 
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       called = true;
       return 1;
     }
   }]);
-
   return Base;
 }();
 
 ;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-not-defined-on-parent-data-on-obj/output.js

@@ -1,13 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-not-defined-on-parent-getter-on-obj/output.js

@@ -1,19 +1,11 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let called = false;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;
@@ -25,13 +17,12 @@ let Obj = /*#__PURE__*/function (_Base) {
     return this.test = 3;
   };
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "test",
     get: function () {
       called = true;
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-not-defined-on-parent-not-on-obj/output.js

@@ -1,13 +1,9 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-not-defined-on-parent-setter-on-obj/output.js

@@ -1,19 +1,11 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let Base = function Base() {};
 
 let value = 2;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;
@@ -25,13 +17,12 @@ let Obj = /*#__PURE__*/function (_Base) {
     return this.test = 3;
   };
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "test",
     set: function (v) {
       value = v;
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set-loose/set-semantics-setter-defined-on-parent/output.js

@@ -1,30 +1,21 @@
 "use strict";
 
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let value = 1;
 
 let Base = /*#__PURE__*/function () {
   function Base() {}
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       value = v;
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inheritsLoose(Obj, _Base);
+  babelHelpers.inheritsLoose(Obj, _Base);
 
   function Obj() {
     return _Base.apply(this, arguments) || this;

packages/babel-plugin-transform-classes/test/fixtures/get-set/call-semantics-data-defined-on-parent/output.js

@@ -1,35 +1,11 @@
 "use strict";
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     value: function test(...args) {
       expect(this).toBe(obj);
@@ -37,31 +13,26 @@ let Base = /*#__PURE__*/function () {
       return 1;
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "call",
     value: function call() {
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, 1, 2, 3);
-
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, 1, ...[2, 3]);
-
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, ...[1, 2, 3]);
-
-      return _get(_getPrototypeOf(Obj.prototype), "test", this).apply(this, arguments);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, 1, 2, 3);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, 1, ...[2, 3]);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, ...[1, 2, 3]);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).apply(this, arguments);
     }
   }, {
     key: "test",
@@ -69,7 +40,6 @@ let Obj = /*#__PURE__*/function (_Base) {
       throw new Error("called");
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/call-semantics-getter-defined-on-parent/output.js

@@ -1,35 +1,11 @@
 "use strict";
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       expect(this).toBe(obj);
@@ -40,31 +16,26 @@ let Base = /*#__PURE__*/function () {
       };
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "call",
     value: function call() {
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, 1, 2, 3);
-
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, 1, ...[2, 3]);
-
-      _get(_getPrototypeOf(Obj.prototype), "test", this).call(this, ...[1, 2, 3]);
-
-      return _get(_getPrototypeOf(Obj.prototype), "test", this).apply(this, arguments);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, 1, 2, 3);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, 1, ...[2, 3]);
+      babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this, ...[1, 2, 3]);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).apply(this, arguments);
     }
   }, {
     key: "test",
@@ -72,7 +43,6 @@ let Obj = /*#__PURE__*/function (_Base) {
       throw new Error("called");
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/call-semantics-not-defined-on-parent/output.js

@@ -1,48 +1,23 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "call",
     value: function call() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this).call(this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this);
     }
   }, {
     key: "test",
@@ -50,7 +25,6 @@ let Obj = /*#__PURE__*/function (_Base) {
       throw new Error("gobbledygook");
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/call-semantics-setter-defined-on-parent/output.js

@@ -1,59 +1,33 @@
 "use strict";
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       throw new Error("gobbledygook");
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "call",
     value: function call() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this).call(this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this).call(this);
     }
   }, {
     key: "test",
@@ -61,7 +35,6 @@ let Obj = /*#__PURE__*/function (_Base) {
       throw new Error("gobbledygook");
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/change-computed-key/output.js

@@ -1,17 +1,11 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let A = /*#__PURE__*/function () {
   "use strict";
 
   function A() {
-    _classCallCheck(this, A);
+    babelHelpers.classCallCheck(this, A);
   }
 
-  _createClass(A, [{
+  babelHelpers.createClass(A, [{
     key: x,
     get: function () {}
   }, {
@@ -21,6 +15,5 @@ let A = /*#__PURE__*/function () {
     key: x,
     set: function (_) {}
   }]);
-
   return A;
 }();

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js

@@ -1,53 +1,27 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 Base.prototype.test = 1;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "get",
     value: function get() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js

@@ -1,63 +1,36 @@
 "use strict";
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       expect(this).toBe(obj);
       return 1;
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "get",
     value: function get() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js

@@ -1,51 +1,25 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "get",
     value: function get() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js

@@ -1,62 +1,35 @@
 "use strict";
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       throw new Error("called");
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "get",
     value: function get() {
-      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+      return babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), "test", this);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/memoized-assign/output.js

@@ -1,37 +1,7 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 Object.defineProperty(Base.prototype, 0, {
@@ -53,32 +23,30 @@ const proper = {
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "assign",
     value: function assign() {
       var _proper$prop;
 
-      _set(_getPrototypeOf(Obj.prototype), _proper$prop = proper.prop, _get(_getPrototypeOf(Obj.prototype), _proper$prop, this) + 1, this, true);
+      babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), _proper$prop = proper.prop, babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), _proper$prop, this) + 1, this, true);
     }
   }, {
     key: "assign2",
     value: function assign2() {
       var _i;
 
-      _set(_getPrototypeOf(Obj.prototype), _i = i, _get(_getPrototypeOf(Obj.prototype), _i, this) + 1, this, true);
+      babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), _i = i, babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), _i, this) + 1, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/memoized-update/output.js

@@ -1,37 +1,7 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 Object.defineProperty(Base.prototype, 0, {
@@ -53,32 +23,30 @@ const proper = {
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "update",
     value: function update() {
       var _proper$prop, _super$proper$prop;
 
-      _set(_getPrototypeOf(Obj.prototype), _proper$prop = proper.prop, (_super$proper$prop = +_get(_getPrototypeOf(Obj.prototype), _proper$prop, this)) + 1, this, true), _super$proper$prop;
+      babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), _proper$prop = proper.prop, (_super$proper$prop = +babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), _proper$prop, this)) + 1, this, true), _super$proper$prop;
     }
   }, {
     key: "update2",
     value: function update2() {
       var _i, _super$i;
 
-      _set(_getPrototypeOf(Obj.prototype), _i = i, (_super$i = +_get(_getPrototypeOf(Obj.prototype), _i, this)) + 1, this, true), _super$i;
+      babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), _i = i, (_super$i = +babelHelpers.get(babelHelpers.getPrototypeOf(Obj.prototype), _i, this)) + 1, this, true), _super$i;
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/method-conflict/output.js

@@ -1,20 +1,13 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let A = /*#__PURE__*/function () {
   "use strict";
 
   function A() {
-    _classCallCheck(this, A);
+    babelHelpers.classCallCheck(this, A);
   }
 
-  _createClass(A, [{
+  babelHelpers.createClass(A, [{
     key: "x",
     set: function (_) {}
   }]);
-
   return A;
 }();

packages/babel-plugin-transform-classes/test/fixtures/get-set/numeric-keys/output.js

@@ -1,17 +1,11 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let A = /*#__PURE__*/function () {
   "use strict";
 
   function A() {
-    _classCallCheck(this, A);
+    babelHelpers.classCallCheck(this, A);
   }
 
-  _createClass(A, [{
+  babelHelpers.createClass(A, [{
     key: "1",
     get: function () {},
     set: function (_) {}
@@ -35,6 +29,5 @@ let A = /*#__PURE__*/function () {
     key: "5n",
     set: function (_) {}
   }]);
-
   return A;
 }();

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js

@@ -1,35 +1,7 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 Object.defineProperty(Base.prototype, 'test', {
@@ -39,23 +11,21 @@ Object.defineProperty(Base.prototype, 'test', {
 });
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js

@@ -1,68 +1,37 @@
 "use strict";
 
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     get: function () {
       return 1;
     }
   }]);
-
   return Base;
 }();
 
 ;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js

@@ -1,55 +1,25 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js

@@ -1,58 +1,28 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "test",
     get: function () {}
   }, {
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js

@@ -1,55 +1,25 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js

@@ -1,51 +1,22 @@
 "use strict";
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 let Base = function Base() {
-  _classCallCheck(this, Base);
+  babelHelpers.classCallCheck(this, Base);
 };
 
 let value = 2;
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "test",
     set: function (v) {
       expect(this).toBe(obj);
@@ -54,10 +25,9 @@ let Obj = /*#__PURE__*/function (_Base) {
   }, {
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js

@@ -1,68 +1,37 @@
 "use strict";
 
-function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
-
-function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 let value = 1;
 
 let Base = /*#__PURE__*/function () {
   function Base() {
-    _classCallCheck(this, Base);
+    babelHelpers.classCallCheck(this, Base);
   }
 
-  _createClass(Base, [{
+  babelHelpers.createClass(Base, [{
     key: "test",
     set: function (v) {
       value = v;
     }
   }]);
-
   return Base;
 }();
 
 let Obj = /*#__PURE__*/function (_Base) {
-  _inherits(Obj, _Base);
+  babelHelpers.inherits(Obj, _Base);
 
-  var _super = _createSuper(Obj);
+  var _super = babelHelpers.createSuper(Obj);
 
   function Obj() {
-    _classCallCheck(this, Obj);
-
+    babelHelpers.classCallCheck(this, Obj);
     return _super.apply(this, arguments);
   }
 
-  _createClass(Obj, [{
+  babelHelpers.createClass(Obj, [{
     key: "set",
     value: function set() {
-      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+      return babelHelpers.set(babelHelpers.getPrototypeOf(Obj.prototype), "test", 3, this, true);
     }
   }]);
-
   return Obj;
 }(Base);
 

packages/babel-plugin-transform-classes/test/fixtures/loose-classCallCheck/with-superClass/output.js

@@ -1,9 +1,3 @@
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
 let B = function B() {
   "use strict";
 };
@@ -11,13 +5,13 @@ let B = function B() {
 let A = /*#__PURE__*/function (_B) {
   "use strict";
 
-  _inheritsLoose(A, _B);
+  babelHelpers.inheritsLoose(A, _B);
 
   function A(track) {
     var _this;
 
     if (track !== undefined) _this = _B.call(this, track) || this;else _this = _B.call(this) || this;
-    return _assertThisInitialized(_this);
+    return babelHelpers.assertThisInitialized(_this);
   }
 
   return A;

packages/babel-plugin-transform-classes/test/fixtures/loose/accessing-super-property-optional-chain/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     ["proposal-optional-chaining", { "loose": true }],
     "transform-function-name",
     ["transform-classes", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/loose/method-return-type-annotation/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     ["transform-classes", { "loose": true }],
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/loose/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     ["transform-classes", { "loose": true }],
     ["transform-spread", { "loose": true }],

packages/babel-plugin-transform-classes/test/fixtures/regression/2663/output.js

@@ -11,15 +11,11 @@ var _events = require("events");
 
 var _binarySerializer = babelHelpers.interopRequireDefault(require("./helpers/binary-serializer"));
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 // import ...
 var Connection = /*#__PURE__*/function (_EventEmitter) {
   babelHelpers.inherits(Connection, _EventEmitter);
 
-  var _super = _createSuper(Connection);
+  var _super = babelHelpers.createSuper(Connection);
 
   function Connection(endpoint, joinKey, joinData, roomId) {
     var _this;

packages/babel-plugin-transform-classes/test/fixtures/regression/2694/options.json

@@ -1,4 +1,3 @@
 {
-  "plugins": ["external-helpers"],
   "presets": [["env", { "targets": { "browsers": "ie 6" } }]]
 }

packages/babel-plugin-transform-classes/test/fixtures/regression/2694/output.js

@@ -7,14 +7,10 @@ exports["default"] = void 0;
 
 var _BaseFoo2 = babelHelpers.interopRequireDefault(require("./BaseFoo"));
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var SubFoo = /*#__PURE__*/function (_BaseFoo) {
   babelHelpers.inherits(SubFoo, _BaseFoo);
 
-  var _super = _createSuper(SubFoo);
+  var _super = babelHelpers.createSuper(SubFoo);
 
   function SubFoo() {
     babelHelpers.classCallCheck(this, SubFoo);

packages/babel-plugin-transform-classes/test/fixtures/regression/2775/output.js

@@ -7,14 +7,10 @@ exports["default"] = void 0;
 
 var _react = babelHelpers.interopRequireDefault(require("react"));
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var RandomComponent = /*#__PURE__*/function (_Component) {
   babelHelpers.inherits(RandomComponent, _Component);
 
-  var _super = _createSuper(RandomComponent);
+  var _super = babelHelpers.createSuper(RandomComponent);
 
   function RandomComponent() {
     babelHelpers.classCallCheck(this, RandomComponent);

packages/babel-plugin-transform-classes/test/fixtures/regression/3028/output.js

@@ -5,10 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var b = function b() {
   babelHelpers.classCallCheck(this, b);
 };
@@ -16,7 +12,7 @@ var b = function b() {
 var a1 = /*#__PURE__*/function (_b) {
   babelHelpers.inherits(a1, _b);
 
-  var _super = _createSuper(a1);
+  var _super = babelHelpers.createSuper(a1);
 
   function a1() {
     var _this;
@@ -37,7 +33,7 @@ var a1 = /*#__PURE__*/function (_b) {
 var a2 = /*#__PURE__*/function (_b2) {
   babelHelpers.inherits(a2, _b2);
 
-  var _super2 = _createSuper(a2);
+  var _super2 = babelHelpers.createSuper(a2);
 
   function a2() {
     var _this2;

packages/babel-plugin-transform-classes/test/fixtures/regression/5769/output.js

@@ -1,7 +1,3 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var Point = /*#__PURE__*/function () {
   "use strict";
 
@@ -23,7 +19,7 @@ var ColorPoint = /*#__PURE__*/function (_Point) {
 
   babelHelpers.inherits(ColorPoint, _Point);
 
-  var _super = _createSuper(ColorPoint);
+  var _super = babelHelpers.createSuper(ColorPoint);
 
   function ColorPoint() {
     var _thisSuper, _thisSuper2, _this;

packages/babel-plugin-transform-classes/test/fixtures/regression/5817/output.js

@@ -1,13 +1,9 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var A = /*#__PURE__*/function (_B) {
   "use strict";
 
   babelHelpers.inherits(A, _B);
 
-  var _super = _createSuper(A);
+  var _super = babelHelpers.createSuper(A);
 
   function A() {
     var _this;

packages/babel-plugin-transform-classes/test/fixtures/regression/8499/output.js

@@ -1,7 +1,3 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var oldReflect = this.Reflect;
 var oldHTMLElement = this.HTMLElement;
 
@@ -22,7 +18,7 @@ try {
 
     babelHelpers.inherits(CustomElement, _HTMLElement);
 
-    var _super = _createSuper(CustomElement);
+    var _super = babelHelpers.createSuper(CustomElement);
 
     function CustomElement() {
       babelHelpers.classCallCheck(this, CustomElement);

packages/babel-plugin-transform-classes/test/fixtures/regression/T2494/output.js

@@ -1,14 +1,10 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var x = {
   Foo: /*#__PURE__*/function (_Foo) {
     "use strict";
 
     babelHelpers.inherits(_class, _Foo);
 
-    var _super = _createSuper(_class);
+    var _super = babelHelpers.createSuper(_class);
 
     function _class() {
       babelHelpers.classCallCheck(this, _class);

packages/babel-plugin-transform-classes/test/fixtures/regression/T2997/output.js

@@ -1,7 +1,3 @@
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
-
-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; } }
-
 var A = function A() {
   "use strict";
 
@@ -13,7 +9,7 @@ var B = /*#__PURE__*/function (_A) {
 
   babelHelpers.inherits(B, _A);
 
-  var _super = _createSuper(B);
+  var _super = babelHelpers.createSuper(B);
 
   function B() {
     var _this;

packages/babel-plugin-transform-classes/test/fixtures/regression/T6755/output.js

@@ -1,7 +1,3 @@
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
 var Example = /*#__PURE__*/function () {
   "use strict";
 
@@ -10,7 +6,7 @@ var Example = /*#__PURE__*/function () {
   var _proto = Example.prototype;
 
   _proto.test1 = /*#__PURE__*/function () {
-    var _test = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    var _test = babelHelpers.asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
       return regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {

packages/babel-plugin-transform-classes/test/fixtures/regression/T7010/options.json

@@ -1,3 +1,3 @@
 {
-  "plugins": ["transform-classes", "external-helpers"]
+  "plugins": ["transform-classes"]
 }

packages/babel-plugin-transform-classes/test/fixtures/regression/T7537/output.js

@@ -1,41 +1,22 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 var B = function B() {
   "use strict";
 
-  _classCallCheck(this, B);
+  babelHelpers.classCallCheck(this, B);
 };
 
 var A = /*#__PURE__*/function (_B) {
   "use strict";
 
-  _inherits(A, _B);
+  babelHelpers.inherits(A, _B);
 
-  var _super = _createSuper(A);
+  var _super = babelHelpers.createSuper(A);
 
   function A(track) {
     var _this;
 
-    _classCallCheck(this, A);
-
+    babelHelpers.classCallCheck(this, A);
     if (track !== undefined) _this = _super.call(this, track);else _this = _super.call(this);
-    return _possibleConstructorReturn(_this);
+    return babelHelpers.possibleConstructorReturn(_this);
   }
 
   return A;

packages/babel-plugin-transform-classes/test/fixtures/regression/options.json

@@ -1,5 +1,5 @@
 {
-  "plugins": ["external-helpers", "proposal-class-properties"],
+  "plugins": ["proposal-class-properties"],
   "presets": [
     ["env", { "targets": { "browsers": "ie 6" } }],
     ["react", { "runtime": "classic" }]

packages/babel-plugin-transform-classes/test/fixtures/spec/accessing-super-property-optional-chain/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "proposal-optional-chaining",
     "transform-function-name",
     "transform-classes",

packages/babel-plugin-transform-classes/test/fixtures/spec/method-return-type-annotation/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/name-method-collision/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/super-destructuring-array-pattern-1/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/super-destructuring-array-pattern/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/super-destructuring-object-pattern-1/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/super-destructuring-object-pattern/options.json

@@ -1,6 +1,5 @@
 {
   "plugins": [
-    "external-helpers",
     "transform-function-name",
     "transform-classes",
     "transform-spread",

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super-inline/output.js

@@ -1,37 +1,15 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 var Foo = /*#__PURE__*/function (_Bar) {
   "use strict";
 
-  _inherits(Foo, _Bar);
+  babelHelpers.inherits(Foo, _Bar);
 
-  var _super = _createSuper(Foo);
+  var _super = babelHelpers.createSuper(Foo);
 
   function Foo() {
     var _thisSuper, _this;
 
-    _classCallCheck(this, Foo);
-
-    _get((_thisSuper = _assertThisInitialized(_this), _getPrototypeOf(Foo.prototype)), "foo", _thisSuper).call(_thisSuper, _this = _super.call(this));
-
+    babelHelpers.classCallCheck(this, Foo);
+    babelHelpers.get((_thisSuper = babelHelpers.assertThisInitialized(_this), babelHelpers.getPrototypeOf(Foo.prototype)), "foo", _thisSuper).call(_thisSuper, _this = _super.call(this));
     return _this;
   }
 

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super/output.js

@@ -1,37 +1,15 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 var Foo = /*#__PURE__*/function (_Bar) {
   "use strict";
 
-  _inherits(Foo, _Bar);
+  babelHelpers.inherits(Foo, _Bar);
 
-  var _super = _createSuper(Foo);
+  var _super = babelHelpers.createSuper(Foo);
 
   function Foo() {
     var _thisSuper, _this;
 
-    _classCallCheck(this, Foo);
-
-    _get((_thisSuper = _assertThisInitialized(_this), _getPrototypeOf(Foo.prototype)), "foo", _thisSuper).call(_thisSuper);
-
+    babelHelpers.classCallCheck(this, Foo);
+    babelHelpers.get((_thisSuper = babelHelpers.assertThisInitialized(_this), babelHelpers.getPrototypeOf(Foo.prototype)), "foo", _thisSuper).call(_thisSuper);
     return _this = _super.call(this);
   }
 

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-in-lambda-2/options.json

@@ -1,7 +1,3 @@
 {
-  "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
-    "transform-classes",
-    "transform-block-scoping"
-  ]
+  "plugins": ["transform-classes", "transform-block-scoping"]
 }

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-in-lambda-3/options.json

@@ -1,7 +1,3 @@
 {
-  "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
-    "transform-classes",
-    "transform-block-scoping"
-  ]
+  "plugins": ["transform-classes", "transform-block-scoping"]
 }

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-in-lambda/options.json

@@ -1,7 +1,3 @@
 {
-  "plugins": [
-    ["external-helpers", { "helperVersion": "7.100.0" }],
-    "transform-classes",
-    "transform-block-scoping"
-  ]
+  "plugins": ["transform-classes", "transform-block-scoping"]
 }