text: function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
  }
  function _getPrototypeOf(o) {
      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
          return o.__proto__ || Object.getPrototypeOf(o);
      }, _getPrototypeOf(o);
  }
  function _inherits(subClass, superClass) {
      if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
      subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
              value: subClass,
              writable: !0,
              configurable: !0
          }
      }), superClass && _setPrototypeOf(subClass, superClass);
  }
  function _possibleConstructorReturn(self, call) {
      return call && ("object" === _typeof(call) || "function" == typeof call) ? call : (function(self) {
          if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          return self;
      })(self);
  }
  function _setPrototypeOf(o, p) {
      return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
          return o.__proto__ = p, o;
      }, _setPrototypeOf(o, p);
  }
  var _typeof = function(obj) {
      return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
  };
  function rec1() {
      return rec2();
  }
  function rec2() {
      return rec1();
  }
  function rec3() {
      return rec4();
  }
  function rec4() {
      return rec3();
  }
  rec1(), rec2(), rec3(), rec4();
  var Base = function() {
      "use strict";
      _classCallCheck(this, Base);
  }, Derived = function(Base) {
      "use strict";
      function Derived() {
          return _classCallCheck(this, Derived), _possibleConstructorReturn(this, _getPrototypeOf(Derived).apply(this, arguments));
      }
      return _inherits(Derived, Base), Derived;
  }(Base);
  new Base(), new Base();
  var Derived2 = function(Base) {
      "use strict";
      function Derived2() {
          return _classCallCheck(this, Derived2), _possibleConstructorReturn(this, _getPrototypeOf(Derived2).apply(this, arguments));
      }
      return _inherits(Derived2, Base), Derived2;
  }(Base), AnotherClass = function() {
      "use strict";
      _classCallCheck(this, AnotherClass);
  };
  