Current Dev State

static/js/ketcher2/node_modules/babel-plugin-transform-es2015-classes/lib/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _symbol = require("babel-runtime/core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+exports.default = function (_ref) {
+  var t = _ref.types;
+
+  var VISITED = (0, _symbol2.default)();
+
+  return {
+    visitor: {
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(path) {
+        if (!path.get("declaration").isClassDeclaration()) return;
+
+        var node = path.node;
+
+        var ref = node.declaration.id || path.scope.generateUidIdentifier("class");
+        node.declaration.id = ref;
+
+        path.replaceWith(node.declaration);
+        path.insertAfter(t.exportDefaultDeclaration(ref));
+      },
+      ClassDeclaration: function ClassDeclaration(path) {
+        var node = path.node;
+
+
+        var ref = node.id || path.scope.generateUidIdentifier("class");
+
+        path.replaceWith(t.variableDeclaration("let", [t.variableDeclarator(ref, t.toExpression(node))]));
+      },
+      ClassExpression: function ClassExpression(path, state) {
+        var node = path.node;
+
+        if (node[VISITED]) return;
+
+        var inferred = (0, _babelHelperFunctionName2.default)(path);
+        if (inferred && inferred !== node) return path.replaceWith(inferred);
+
+        node[VISITED] = true;
+
+        var Constructor = _vanilla2.default;
+        if (state.opts.loose) Constructor = _loose2.default;
+
+        path.replaceWith(new Constructor(path, state.file).run());
+      }
+    }
+  };
+};
+
+var _loose = require("./loose");
+
+var _loose2 = _interopRequireDefault(_loose);
+
+var _vanilla = require("./vanilla");
+
+var _vanilla2 = _interopRequireDefault(_vanilla);
+
+var _babelHelperFunctionName = require("babel-helper-function-name");
+
+var _babelHelperFunctionName2 = _interopRequireDefault(_babelHelperFunctionName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports["default"];

static/js/ketcher2/node_modules/babel-plugin-transform-es2015-classes/lib/lib/memoise-decorators.js

@@ -0,0 +1,59 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.default = function (decorators, scope) {
+  for (var _iterator = decorators, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var decorator = _ref;
+
+    var expression = decorator.expression;
+    if (!t.isMemberExpression(expression)) continue;
+
+    var temp = scope.maybeGenerateMemoised(expression.object);
+    var ref = void 0;
+
+    var nodes = [];
+
+    if (temp) {
+      ref = temp;
+      nodes.push(t.assignmentExpression("=", temp, expression.object));
+    } else {
+      ref = expression.object;
+    }
+
+    nodes.push(t.callExpression(t.memberExpression(t.memberExpression(ref, expression.property, expression.computed), t.identifier("bind")), [ref]));
+
+    if (nodes.length === 1) {
+      decorator.expression = nodes[0];
+    } else {
+      decorator.expression = t.sequenceExpression(nodes);
+    }
+  }
+
+  return decorators;
+};
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports["default"];

static/js/ketcher2/node_modules/babel-plugin-transform-es2015-classes/lib/loose.js

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require("babel-runtime/helpers/inherits");
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _babelHelperFunctionName = require("babel-helper-function-name");
+
+var _babelHelperFunctionName2 = _interopRequireDefault(_babelHelperFunctionName);
+
+var _vanilla = require("./vanilla");
+
+var _vanilla2 = _interopRequireDefault(_vanilla);
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var LooseClassTransformer = function (_VanillaTransformer) {
+  (0, _inherits3.default)(LooseClassTransformer, _VanillaTransformer);
+
+  function LooseClassTransformer() {
+    (0, _classCallCheck3.default)(this, LooseClassTransformer);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, _VanillaTransformer.apply(this, arguments));
+
+    _this.isLoose = true;
+    return _this;
+  }
+
+  LooseClassTransformer.prototype._processMethod = function _processMethod(node, scope) {
+    if (!node.decorators) {
+
+      var classRef = this.classRef;
+      if (!node.static) classRef = t.memberExpression(classRef, t.identifier("prototype"));
+      var methodName = t.memberExpression(classRef, node.key, node.computed || t.isLiteral(node.key));
+
+      var func = t.functionExpression(null, node.params, node.body, node.generator, node.async);
+      func.returnType = node.returnType;
+      var key = t.toComputedKey(node, node.key);
+      if (t.isStringLiteral(key)) {
+        func = (0, _babelHelperFunctionName2.default)({
+          node: func,
+          id: key,
+          scope: scope
+        });
+      }
+
+      var expr = t.expressionStatement(t.assignmentExpression("=", methodName, func));
+      t.inheritsComments(expr, node);
+      this.body.push(expr);
+      return true;
+    }
+  };
+
+  return LooseClassTransformer;
+}(_vanilla2.default);
+
+exports.default = LooseClassTransformer;
+module.exports = exports["default"];

static/js/ketcher2/node_modules/babel-plugin-transform-es2015-classes/lib/vanilla.js

@@ -0,0 +1,559 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _babelTraverse = require("babel-traverse");
+
+var _babelHelperReplaceSupers = require("babel-helper-replace-supers");
+
+var _babelHelperReplaceSupers2 = _interopRequireDefault(_babelHelperReplaceSupers);
+
+var _babelHelperOptimiseCallExpression = require("babel-helper-optimise-call-expression");
+
+var _babelHelperOptimiseCallExpression2 = _interopRequireDefault(_babelHelperOptimiseCallExpression);
+
+var _babelHelperDefineMap = require("babel-helper-define-map");
+
+var defineMap = _interopRequireWildcard(_babelHelperDefineMap);
+
+var _babelTemplate = require("babel-template");
+
+var _babelTemplate2 = _interopRequireDefault(_babelTemplate);
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var buildDerivedConstructor = (0, _babelTemplate2.default)("\n  (function () {\n    super(...arguments);\n  })\n");
+
+var noMethodVisitor = {
+  "FunctionExpression|FunctionDeclaration": function FunctionExpressionFunctionDeclaration(path) {
+    if (!path.is("shadow")) {
+      path.skip();
+    }
+  },
+  Method: function Method(path) {
+    path.skip();
+  }
+};
+
+var verifyConstructorVisitor = _babelTraverse.visitors.merge([noMethodVisitor, {
+  Super: function Super(path) {
+    if (this.isDerived && !this.hasBareSuper && !path.parentPath.isCallExpression({ callee: path.node })) {
+      throw path.buildCodeFrameError("'super.*' is not allowed before super()");
+    }
+  },
+
+
+  CallExpression: {
+    exit: function exit(path) {
+      if (path.get("callee").isSuper()) {
+        this.hasBareSuper = true;
+
+        if (!this.isDerived) {
+          throw path.buildCodeFrameError("super() is only allowed in a derived constructor");
+        }
+      }
+    }
+  },
+
+  ThisExpression: function ThisExpression(path) {
+    if (this.isDerived && !this.hasBareSuper) {
+      if (!path.inShadow("this")) {
+        throw path.buildCodeFrameError("'this' is not allowed before super()");
+      }
+    }
+  }
+}]);
+
+var findThisesVisitor = _babelTraverse.visitors.merge([noMethodVisitor, {
+  ThisExpression: function ThisExpression(path) {
+    this.superThises.push(path);
+  }
+}]);
+
+var ClassTransformer = function () {
+  function ClassTransformer(path, file) {
+    (0, _classCallCheck3.default)(this, ClassTransformer);
+
+    this.parent = path.parent;
+    this.scope = path.scope;
+    this.node = path.node;
+    this.path = path;
+    this.file = file;
+
+    this.clearDescriptors();
+
+    this.instancePropBody = [];
+    this.instancePropRefs = {};
+    this.staticPropBody = [];
+    this.body = [];
+
+    this.bareSuperAfter = [];
+    this.bareSupers = [];
+
+    this.pushedConstructor = false;
+    this.pushedInherits = false;
+    this.isLoose = false;
+
+    this.superThises = [];
+
+    this.classId = this.node.id;
+
+    this.classRef = this.node.id ? t.identifier(this.node.id.name) : this.scope.generateUidIdentifier("class");
+
+    this.superName = this.node.superClass || t.identifier("Function");
+    this.isDerived = !!this.node.superClass;
+  }
+
+  ClassTransformer.prototype.run = function run() {
+    var _this = this;
+
+    var superName = this.superName;
+    var file = this.file;
+    var body = this.body;
+
+    var constructorBody = this.constructorBody = t.blockStatement([]);
+    this.constructor = this.buildConstructor();
+
+    var closureParams = [];
+    var closureArgs = [];
+
+    if (this.isDerived) {
+      closureArgs.push(superName);
+
+      superName = this.scope.generateUidIdentifierBasedOnNode(superName);
+      closureParams.push(superName);
+
+      this.superName = superName;
+    }
+
+    this.buildBody();
+
+    constructorBody.body.unshift(t.expressionStatement(t.callExpression(file.addHelper("classCallCheck"), [t.thisExpression(), this.classRef])));
+
+    body = body.concat(this.staticPropBody.map(function (fn) {
+      return fn(_this.classRef);
+    }));
+
+    if (this.classId) {
+      if (body.length === 1) return t.toExpression(body[0]);
+    }
+
+    body.push(t.returnStatement(this.classRef));
+
+    var container = t.functionExpression(null, closureParams, t.blockStatement(body));
+    container.shadow = true;
+    return t.callExpression(container, closureArgs);
+  };
+
+  ClassTransformer.prototype.buildConstructor = function buildConstructor() {
+    var func = t.functionDeclaration(this.classRef, [], this.constructorBody);
+    t.inherits(func, this.node);
+    return func;
+  };
+
+  ClassTransformer.prototype.pushToMap = function pushToMap(node, enumerable) {
+    var kind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "value";
+    var scope = arguments[3];
+
+    var mutatorMap = void 0;
+    if (node.static) {
+      this.hasStaticDescriptors = true;
+      mutatorMap = this.staticMutatorMap;
+    } else {
+      this.hasInstanceDescriptors = true;
+      mutatorMap = this.instanceMutatorMap;
+    }
+
+    var map = defineMap.push(mutatorMap, node, kind, this.file, scope);
+
+    if (enumerable) {
+      map.enumerable = t.booleanLiteral(true);
+    }
+
+    return map;
+  };
+
+  ClassTransformer.prototype.constructorMeMaybe = function constructorMeMaybe() {
+    var hasConstructor = false;
+    var paths = this.path.get("body.body");
+    for (var _iterator = paths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var path = _ref;
+
+      hasConstructor = path.equals("kind", "constructor");
+      if (hasConstructor) break;
+    }
+    if (hasConstructor) return;
+
+    var params = void 0,
+        body = void 0;
+
+    if (this.isDerived) {
+      var _constructor = buildDerivedConstructor().expression;
+      params = _constructor.params;
+      body = _constructor.body;
+    } else {
+      params = [];
+      body = t.blockStatement([]);
+    }
+
+    this.path.get("body").unshiftContainer("body", t.classMethod("constructor", t.identifier("constructor"), params, body));
+  };
+
+  ClassTransformer.prototype.buildBody = function buildBody() {
+    this.constructorMeMaybe();
+    this.pushBody();
+    this.verifyConstructor();
+
+    if (this.userConstructor) {
+      var constructorBody = this.constructorBody;
+      constructorBody.body = constructorBody.body.concat(this.userConstructor.body.body);
+      t.inherits(this.constructor, this.userConstructor);
+      t.inherits(constructorBody, this.userConstructor.body);
+    }
+
+    this.pushDescriptors();
+  };
+
+  ClassTransformer.prototype.pushBody = function pushBody() {
+    var classBodyPaths = this.path.get("body.body");
+
+    for (var _iterator2 = classBodyPaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      var path = _ref2;
+
+      var node = path.node;
+
+      if (path.isClassProperty()) {
+        throw path.buildCodeFrameError("Missing class properties transform.");
+      }
+
+      if (node.decorators) {
+        throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
+      }
+
+      if (t.isClassMethod(node)) {
+        var isConstructor = node.kind === "constructor";
+
+        if (isConstructor) {
+          path.traverse(verifyConstructorVisitor, this);
+
+          if (!this.hasBareSuper && this.isDerived) {
+            throw path.buildCodeFrameError("missing super() call in constructor");
+          }
+        }
+
+        var replaceSupers = new _babelHelperReplaceSupers2.default({
+          forceSuperMemoisation: isConstructor,
+          methodPath: path,
+          methodNode: node,
+          objectRef: this.classRef,
+          superRef: this.superName,
+          isStatic: node.static,
+          isLoose: this.isLoose,
+          scope: this.scope,
+          file: this.file
+        }, true);
+
+        replaceSupers.replace();
+
+        if (isConstructor) {
+          this.pushConstructor(replaceSupers, node, path);
+        } else {
+          this.pushMethod(node, path);
+        }
+      }
+    }
+  };
+
+  ClassTransformer.prototype.clearDescriptors = function clearDescriptors() {
+    this.hasInstanceDescriptors = false;
+    this.hasStaticDescriptors = false;
+
+    this.instanceMutatorMap = {};
+    this.staticMutatorMap = {};
+  };
+
+  ClassTransformer.prototype.pushDescriptors = function pushDescriptors() {
+    this.pushInherits();
+
+    var body = this.body;
+
+    var instanceProps = void 0;
+    var staticProps = void 0;
+
+    if (this.hasInstanceDescriptors) {
+      instanceProps = defineMap.toClassObject(this.instanceMutatorMap);
+    }
+
+    if (this.hasStaticDescriptors) {
+      staticProps = defineMap.toClassObject(this.staticMutatorMap);
+    }
+
+    if (instanceProps || staticProps) {
+      if (instanceProps) instanceProps = defineMap.toComputedObjectFromClass(instanceProps);
+      if (staticProps) staticProps = defineMap.toComputedObjectFromClass(staticProps);
+
+      var nullNode = t.nullLiteral();
+
+      var args = [this.classRef, nullNode, nullNode, nullNode, nullNode];
+
+      if (instanceProps) args[1] = instanceProps;
+      if (staticProps) args[2] = staticProps;
+
+      if (this.instanceInitializersId) {
+        args[3] = this.instanceInitializersId;
+        body.unshift(this.buildObjectAssignment(this.instanceInitializersId));
+      }
+
+      if (this.staticInitializersId) {
+        args[4] = this.staticInitializersId;
+        body.unshift(this.buildObjectAssignment(this.staticInitializersId));
+      }
+
+      var lastNonNullIndex = 0;
+      for (var i = 0; i < args.length; i++) {
+        if (args[i] !== nullNode) lastNonNullIndex = i;
+      }
+      args = args.slice(0, lastNonNullIndex + 1);
+
+      body.push(t.expressionStatement(t.callExpression(this.file.addHelper("createClass"), args)));
+    }
+
+    this.clearDescriptors();
+  };
+
+  ClassTransformer.prototype.buildObjectAssignment = function buildObjectAssignment(id) {
+    return t.variableDeclaration("var", [t.variableDeclarator(id, t.objectExpression([]))]);
+  };
+
+  ClassTransformer.prototype.wrapSuperCall = function wrapSuperCall(bareSuper, superRef, thisRef, body) {
+    var bareSuperNode = bareSuper.node;
+
+    if (this.isLoose) {
+      bareSuperNode.arguments.unshift(t.thisExpression());
+      if (bareSuperNode.arguments.length === 2 && t.isSpreadElement(bareSuperNode.arguments[1]) && t.isIdentifier(bareSuperNode.arguments[1].argument, { name: "arguments" })) {
+        bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
+        bareSuperNode.callee = t.memberExpression(superRef, t.identifier("apply"));
+      } else {
+        bareSuperNode.callee = t.memberExpression(superRef, t.identifier("call"));
+      }
+    } else {
+      bareSuperNode = (0, _babelHelperOptimiseCallExpression2.default)(t.logicalExpression("||", t.memberExpression(this.classRef, t.identifier("__proto__")), t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")), [this.classRef])), t.thisExpression(), bareSuperNode.arguments);
+    }
+
+    var call = t.callExpression(this.file.addHelper("possibleConstructorReturn"), [t.thisExpression(), bareSuperNode]);
+
+    var bareSuperAfter = this.bareSuperAfter.map(function (fn) {
+      return fn(thisRef);
+    });
+
+    if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
+
+      if (this.superThises.length || bareSuperAfter.length) {
+        bareSuper.scope.push({ id: thisRef });
+        call = t.assignmentExpression("=", thisRef, call);
+      }
+
+      if (bareSuperAfter.length) {
+        call = t.toSequenceExpression([call].concat(bareSuperAfter, [thisRef]));
+      }
+
+      bareSuper.parentPath.replaceWith(t.returnStatement(call));
+    } else {
+      bareSuper.replaceWithMultiple([t.variableDeclaration("var", [t.variableDeclarator(thisRef, call)])].concat(bareSuperAfter, [t.expressionStatement(thisRef)]));
+    }
+  };
+
+  ClassTransformer.prototype.verifyConstructor = function verifyConstructor() {
+    var _this2 = this;
+
+    if (!this.isDerived) return;
+
+    var path = this.userConstructorPath;
+    var body = path.get("body");
+
+    path.traverse(findThisesVisitor, this);
+
+    var guaranteedSuperBeforeFinish = !!this.bareSupers.length;
+
+    var superRef = this.superName || t.identifier("Function");
+    var thisRef = path.scope.generateUidIdentifier("this");
+
+    for (var _iterator3 = this.bareSupers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      var bareSuper = _ref3;
+
+      this.wrapSuperCall(bareSuper, superRef, thisRef, body);
+
+      if (guaranteedSuperBeforeFinish) {
+        bareSuper.find(function (parentPath) {
+          if (parentPath === path) {
+            return true;
+          }
+
+          if (parentPath.isLoop() || parentPath.isConditional()) {
+            guaranteedSuperBeforeFinish = false;
+            return true;
+          }
+        });
+      }
+    }
+
+    for (var _iterator4 = this.superThises, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
+      var _ref4;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref4 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref4 = _i4.value;
+      }
+
+      var thisPath = _ref4;
+
+      thisPath.replaceWith(thisRef);
+    }
+
+    var wrapReturn = function wrapReturn(returnArg) {
+      return t.callExpression(_this2.file.addHelper("possibleConstructorReturn"), [thisRef].concat(returnArg || []));
+    };
+
+    var bodyPaths = body.get("body");
+    if (bodyPaths.length && !bodyPaths.pop().isReturnStatement()) {
+      body.pushContainer("body", t.returnStatement(guaranteedSuperBeforeFinish ? thisRef : wrapReturn()));
+    }
+
+    for (var _iterator5 = this.superReturns, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) {
+      var _ref5;
+
+      if (_isArray5) {
+        if (_i5 >= _iterator5.length) break;
+        _ref5 = _iterator5[_i5++];
+      } else {
+        _i5 = _iterator5.next();
+        if (_i5.done) break;
+        _ref5 = _i5.value;
+      }
+
+      var returnPath = _ref5;
+
+      if (returnPath.node.argument) {
+        var ref = returnPath.scope.generateDeclaredUidIdentifier("ret");
+        returnPath.get("argument").replaceWithMultiple([t.assignmentExpression("=", ref, returnPath.node.argument), wrapReturn(ref)]);
+      } else {
+        returnPath.get("argument").replaceWith(wrapReturn());
+      }
+    }
+  };
+
+  ClassTransformer.prototype.pushMethod = function pushMethod(node, path) {
+    var scope = path ? path.scope : this.scope;
+
+    if (node.kind === "method") {
+      if (this._processMethod(node, scope)) return;
+    }
+
+    this.pushToMap(node, false, null, scope);
+  };
+
+  ClassTransformer.prototype._processMethod = function _processMethod() {
+    return false;
+  };
+
+  ClassTransformer.prototype.pushConstructor = function pushConstructor(replaceSupers, method, path) {
+    this.bareSupers = replaceSupers.bareSupers;
+    this.superReturns = replaceSupers.returns;
+
+    if (path.scope.hasOwnBinding(this.classRef.name)) {
+      path.scope.rename(this.classRef.name);
+    }
+
+    var construct = this.constructor;
+
+    this.userConstructorPath = path;
+    this.userConstructor = method;
+    this.hasConstructor = true;
+
+    t.inheritsComments(construct, method);
+
+    construct._ignoreUserWhitespace = true;
+    construct.params = method.params;
+
+    t.inherits(construct.body, method.body);
+    construct.body.directives = method.body.directives;
+
+    this._pushConstructor();
+  };
+
+  ClassTransformer.prototype._pushConstructor = function _pushConstructor() {
+    if (this.pushedConstructor) return;
+    this.pushedConstructor = true;
+
+    if (this.hasInstanceDescriptors || this.hasStaticDescriptors) {
+      this.pushDescriptors();
+    }
+
+    this.body.push(this.constructor);
+
+    this.pushInherits();
+  };
+
+  ClassTransformer.prototype.pushInherits = function pushInherits() {
+    if (!this.isDerived || this.pushedInherits) return;
+
+    this.pushedInherits = true;
+    this.body.unshift(t.expressionStatement(t.callExpression(this.file.addHelper("inherits"), [this.classRef, this.superName])));
+  };
+
+  return ClassTransformer;
+}();
+
+exports.default = ClassTransformer;
+module.exports = exports["default"];