v3.3.8

CHANGELOG.md

@@ -11,6 +11,19 @@
 
 _Note: Gaps between patch versions are faulty/broken releases._
 
+## 3.3.8
+
+ * **Bug Fix**
+  * Fix super inside of functions.
+  * Fix super constructor inheritance.
+
+## 3.3.7
+
+ * **Bug Fix**
+  * Add `--use-strict` to valid node flags in `6to5-node`.
+  * Fix booleans not being properly stripped from the arguments in `6to5-node`.
+  * Force `.js` extension when writing files to directories with `6to5`.
+
 ## 3.3.5
 
  * **Bug Fix**

bin/6to5-minify

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var opts = require("./6to5").opts;
+opts.optional = (opts.optional || []).concat("minification");
+opts.format = {
+  compact: true
+};

bin/6to5-node

@@ -35,6 +35,7 @@ process.argv.slice(2).forEach(function(arg){
     case "--prof":
     case "--throw-deprecation":
     case "--trace-deprecation":
+    case "--use-strict":
       args.unshift(arg);
       break;
 

bin/6to5/dir.js

@@ -11,6 +11,9 @@ module.exports = function (commander, filenames, opts) {
   }
 
   var write = function (src, relative) {
+    // remove extension and then append back on .js
+    relative = relative.replace(/\.(\w*?)$/, "") + ".js";
+
     var dest = path.join(commander.outDir, relative);
 
     var data = util.compile(src, { sourceMapName: dest });

bin/6to5/index.js

@@ -114,12 +114,17 @@ exports.opts = {
   loose:                  commander.loose
 };
 
-var fn;
+setTimeout(function () {
+  // this is just a hack to give `6to5-minify` and other files including this
+  // time to modify `exports.opts`
 
-if (commander.outDir) {
-  fn = require("./dir");
-} else {
-  fn = require("./file");
-}
+  var fn;
 
-fn(commander, filenames, exports.opts);
+  if (commander.outDir) {
+    fn = require("./dir");
+  } else {
+    fn = require("./file");
+  }
+
+  fn(commander, filenames, exports.opts);
+}, 0);

bin/_6to5-node

@@ -72,7 +72,8 @@ if (program.eval || program.print) {
       }
 
       if (arg[0] === "-") {
-        if (program[arg.slice(2)]) {
+        var parsedArg = program[arg.slice(2)];
+        if (parsedArg && parsedArg !== true) {
           ignoreNext = true;
         }
       } else {

lib/6to5/generation/buffer.js

@@ -19,7 +19,7 @@ Buffer.prototype.get = function () {
 };
 
 Buffer.prototype.getIndent = function () {
-  if (this.format.compact) {
+  if (this.format.compact || this.format.concise) {
     return "";
   } else {
     return util.repeat(this._indent, this.format.indent.style);
@@ -53,10 +53,12 @@ Buffer.prototype.rightBrace = function () {
 
 Buffer.prototype.keyword = function (name) {
   this.push(name);
-  this.push(" ");
+  this.space();
 };
 
 Buffer.prototype.space = function () {
+  if (this.format.compact) return;
+
   if (this.buf && !this.isLast([" ", "\n"])) {
     this.push(" ");
   }
@@ -70,7 +72,7 @@ Buffer.prototype.removeLast = function (cha) {
 };
 
 Buffer.prototype.newline = function (i, removeLast) {
-  if (this.format.compact) {
+  if (this.format.compact || this.format.concise) {
     this.space();
     return;
   }

lib/6to5/generation/generators/expressions.js

@@ -17,7 +17,7 @@ exports.UnaryExpression = function (node, print) {
   }
 
   this.push(node.operator);
-  if (hasSpace) this.space();
+  if (hasSpace) this.push(" ");
   print(node.argument);
 };
 
@@ -33,9 +33,13 @@ exports.UpdateExpression = function (node, print) {
 
 exports.ConditionalExpression = function (node, print) {
   print(node.test);
-  this.push(" ? ");
+  this.space();
+  this.push("?");
+  this.space();
   print(node.consequent);
-  this.push(" : ");
+  this.space();
+  this.push(":");
+  this.space();
   print(node.alternate);
 };
 
@@ -44,13 +48,13 @@ exports.NewExpression = function (node, print) {
   print(node.callee);
   if (node.arguments.length || this.format.parentheses) {
     this.push("(");
-    print.join(node.arguments, { separator: ", " });
+    print.list(node.arguments);
     this.push(")");
   }
 };
 
 exports.SequenceExpression = function (node, print) {
-  print.join(node.expressions, { separator: ", " });
+  print.list(node.expressions);
 };
 
 exports.ThisExpression = function () {
@@ -72,9 +76,7 @@ exports.CallExpression = function (node, print) {
     separator += " ";
   }
 
-  print.join(node.arguments, {
-    separator: separator
-  });
+  print.list(node.arguments, { separator: separator });
 
   if (node._prettyCall) {
     this.newline();
@@ -115,10 +117,11 @@ exports.BinaryExpression =
 exports.LogicalExpression =
 exports.AssignmentPattern =
 exports.AssignmentExpression = function (node, print) {
+  // todo: add cases where the spaces can be dropped when in compact mode
   print(node.left);
-  this.space();
+  this.push(" ");
   this.push(node.operator);
-  this.space();
+  this.push(" ");
   print(node.right);
 };
 

lib/6to5/generation/generators/methods.js

@@ -4,11 +4,7 @@ var t = require("../../types");
 
 exports._params = function (node, print) {
   this.push("(");
-
-  print.join(node.params, {
-    separator: ", "
-  });
-
+  print.list(node.params);
   this.push(")");
 };
 
@@ -45,11 +41,14 @@ exports.FunctionExpression = function (node, print) {
   if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
-  this.push(" ");
+
   if (node.id) {
-    this.space();
+    this.push(" ");
     print(node.id);
+  } else {
+    this.space();
   }
+
   this._params(node, print);
   this.space();
   print(node.body);

lib/6to5/generation/generators/statements.js

@@ -23,6 +23,11 @@ exports.IfStatement = function (node, print) {
   if (node.alternate) {
     if (this.isLast("}")) this.push(" ");
     this.keyword("else");
+
+    if (this.format.format && !t.isBlockStatement(node.alternate)) {
+      this.push(" ");
+    }
+
     print.indentOnComments(node.alternate);
   }
 };
@@ -190,7 +195,7 @@ exports.VariableDeclaration = function (node, print, parent) {
     sep += " ";
   }
 
-  print.join(node.declarations, { separator: sep });
+  print.list(node.declarations, { separator: sep });
 
   if (!t.isFor(parent)) {
     this.semicolon();

lib/6to5/generation/generators/types.js

@@ -27,7 +27,7 @@ exports.ObjectPattern = function (node, print) {
     this.push("{");
     this.space();
 
-    print.join(props, { separator: ", ", indent: true });
+    print.list(props, { indent: true });
 
     this.space();
     this.push("}");
@@ -49,7 +49,8 @@ exports.Property = function (node, print) {
       if (node.shorthand) return;
     }
 
-    this.push(": ");
+    this.push(":");
+    this.space();
     print(node.value);
   }
 };
@@ -71,7 +72,7 @@ exports.ArrayPattern = function (node, print) {
       // both (all) of the holes.
       self.push(",");
     } else {
-      if (i > 0) self.push(" ");
+      if (i > 0 && !self.format.compact) self.push(" ");
       print(elem);
       if (i < len - 1) self.push(",");
     }

lib/6to5/generation/index.js

@@ -50,6 +50,7 @@ CodeGenerator.normalizeOptions = function (code, opts) {
     parentheses: true,
     comments: opts.comments == null || opts.comments,
     compact: false,
+    concise: false,
     indent: {
       adjustMultilineComment: true,
       style: style,
@@ -111,6 +112,16 @@ CodeGenerator.prototype.buildPrint = function (parent) {
     return self.printJoin(print, nodes, opts);
   };
 
+  print.list = function (items, opts) {
+    opts = opts || {};
+
+    var sep = opts.separator || ", ";
+    if (self.format.compact) sep = ",";
+    opts.separator = sep;
+
+    print.join(items, opts);
+  };
+
   print.block = function (node) {
     return self.printBlock(print, node);
   };
@@ -129,9 +140,9 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
     node._compact = true;
   }
 
-  var oldCompact = this.format.compact;
+  var oldConcise = this.format.concise;
   if (node._compact) {
-    this.format.compact = true;
+    this.format.concise = true;
   }
 
   var self = this;
@@ -198,7 +209,7 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
     throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
   }
 
-  this.format.compact = oldCompact;
+  this.format.concise = oldConcise;
 };
 
 CodeGenerator.prototype.printJoin = function (print, nodes, opts) {

lib/6to5/transformation/helpers/replace-supers.js

@@ -150,7 +150,7 @@ var visitor = {
       // top level so `this` is the instance
       t.thisExpression :
       // not in the top level so we need to create a reference
-      self.getThisReference;
+      self.getThisReference.bind(self);
 
     var callback = self.specHandle;
     if (self.isLoose) callback = self.looseHandle;

lib/6to5/transformation/templates/class-super-constructor-call.js

@@ -1,5 +1,3 @@
-(function (instance, Constructor) {
-  if (Object.getPrototypeOf(Constructor) !== null) {
-    Object.getPrototypeOf(Constructor).apply(instance, arguments);
-  }
-});
+if (Object.getPrototypeOf(CLASS_NAME) !== null) {
+  Object.getPrototypeOf(CLASS_NAME).apply(this, arguments);
+}

lib/6to5/transformation/transformers/es6/classes.js

@@ -169,19 +169,11 @@ Class.prototype.buildBody = function () {
   // we have no constructor, we have a super, and the super doesn't appear to be falsy
   if (!this.hasConstructor && superName && !t.isFalsyExpression(superName)) {
     var helperName = "class-super-constructor-call";
-
-    if (this.isLoose) {
-      constructor.body.body.push(util.template(helperName + "-loose", {
-        CLASS_NAME: className,
-        SUPER_NAME: this.superName
-      }, true));
-    } else {
-      constructor.body.body.push(
-        t.expressionStatement(
-          t.callExpression(this.file.addHelper(helperName), [t.thisExpression(), className])
-        )
-      );
-    }
+    if (this.isLoose) helperName += "-loose";
+    constructor.body.body.push(util.template(helperName, {
+      CLASS_NAME: className,
+      SUPER_NAME: this.superName
+    }, true));
   }
 
   var instanceProps;

lib/6to5/transformation/transformers/index.js

@@ -80,5 +80,10 @@ module.exports = {
   "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
 
   "minification.propertyLiterals":         require("./minification/property-literals"),
-  "minification.memberExpressionLiterals": require("./minification/member-expression-literals")
+  "minification.memberExpressionLiterals": require("./minification/member-expression-literals"),
+
+  "minification.removeDebugger":           require("./minification/remove-debugger"),
+  "minification.removeConsoleCalls":       require("./minification/remove-console-calls"),
+  "minification.deadCodeElimination":      require("./minification/dead-code-elimination"),
+  "minification.renameLocalVariables":     require("./minification/rename-local-variables")
 };

lib/6to5/transformation/transformers/minification/dead-code-elimination.js

@@ -0,0 +1,77 @@
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.ExpressionStatement = function (node, parent, scope, context) {
+  // remove consequenceless expressions such as local variables and literals
+  //
+  //   var foo = true; foo; -> var foo = true;
+  //   "foo"; ->
+  //
+
+  var expr = node.expression;
+  if (t.isLiteral(expr) || (t.isIdentifier(node) && t.hasBinding(node.name))) {
+    context.remove();
+  }
+};
+
+exports.IfStatement = {
+  exit: function (node, parent, scope, context) {
+    // todo: in scenarios where we can just return the consequent or
+    // alternate we should drop the block statement if it contains no
+    // block scoped variables
+
+    var consequent = node.consequent;
+    var alternate  = node.alternate;
+    var test       = node.test;
+
+    // we can check if a test will be truthy 100% and if so we can inline
+    // the consequent and completely ignore the alternate
+    //
+    //   if (true) { foo; } -> { foo; }
+    //   if ("foo") { foo; } -> { foo; }
+    //
+
+    if (t.isLiteral(test) && test.value) {
+      return alternate;
+    }
+
+    // we can check if a test will be falsy 100% and if so we can inline
+    // the alternate if there is one and completely remove the consequent
+    //
+    //   if ("") { bar; } else { foo; } -> { foo; }
+    //   if ("") { bar; } ->
+    //
+
+    if (t.isFalsyExpression(test)) {
+      if (alternate) {
+        return alternate;
+      } else {
+        return context.remove();
+      }
+    }
+
+    // remove alternate blocks that are empty
+    //
+    //   if (foo) { foo; } else {} -> if (foo) { foo; }
+    //
+
+    if (t.isBlockStatement(alternate) && !alternate.body.length) {
+      alternate = node.alternate = null;
+    }
+
+    // turn alternate blocks into a consequent and flip the test if the
+    // consequent block is empty
+    //
+    //   if (foo) {} else { bar; }
+    //   if (!foo) { bar; }
+    //
+
+    if (t.blockStatement(consequent) && !consequent.body.length &&
+        t.isBlockStatement(alternate) && alternate.body.length) {
+      node.consequent = node.alternate;
+      node.alternate  = null;
+      node.test       = t.unaryExpression("!", test, true);
+    }
+  }
+};

lib/6to5/transformation/transformers/minification/remove-console-calls.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var t = require("../../../types");
+
+var isConsole = t.buildMatchMemberExpression("console", true);
+
+exports.optional = true;
+
+exports.CallExpression = function (node, parent, scope, context) {
+  if (isConsole(node.callee)) {
+    context.remove();
+  }
+};

lib/6to5/transformation/transformers/minification/remove-debugger.js

@@ -0,0 +1,9 @@
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.ExpressionStatement = function (node, parent, scope, context) {
+  if (t.isIdentifier(node.expression, { name: "debugger" })) {
+    context.remove();
+  }
+};

lib/6to5/transformation/transformers/minification/rename-local-variables.js

@@ -0,0 +1,10 @@
+//var t = require("../../../types");
+
+exports.optional = true;
+
+exports.Scope = function () {
+  // todo: get all binding identifiers, generate compact names
+  // that wont collide and then call the remap identifier helper
+  // this transformer **has** to be ran last as it will absolutley
+  // destroy the scope tree
+};

lib/6to5/traverse/index.js

@@ -41,6 +41,13 @@ TraversalContext.prototype.reset = function () {
   this.shouldStop   = false;
 };
 
+TraversalContext.prototype.maybeRemove = function (obj, key) {
+  if (this.shouldRemove) {
+    obj[key] = null;
+    this.shouldFlatten = true;
+  }
+};
+
 function replaceNode(obj, key, node, result) {
   var isArray = Array.isArray(result);
 
@@ -76,10 +83,7 @@ TraversalContext.prototype.enterNode = function (obj, key, node, enter, parent,
     }
   }
 
-  if (this.shouldRemove) {
-    obj[key] = null;
-    this.shouldFlatten = true;
-  }
+  this.maybeRemove(obj, key);
 
   return node;
 };
@@ -97,6 +101,8 @@ TraversalContext.prototype.exitNode = function (obj, key, node, exit, parent, sc
     }
   }
 
+  this.maybeRemove(obj, key);
+
   return node;
 };
 

lib/6to5/traverse/scope.js

@@ -30,11 +30,7 @@ function Scope(block, parentBlock, parent, file) {
   this.parentBlock = parentBlock;
   this.block       = block;
 
-  var info = this.getInfo();
-
-  this.references       = info.references;
-  this.bindings         = info.bindings;
-  this.declarationKinds = info.declarationKinds;
+  this.crawl();
 }
 
 Scope.defaultDeclarations = flatten([globals.builtin, globals.browser, globals.node].map(Object.keys));
@@ -126,12 +122,91 @@ Scope.prototype.generateTempBasedOnNode = function (node) {
   return id;
 };
 
+Scope.prototype.checkBlockScopedCollisions = function (key, id) {
+  if (this.declarationKinds["let"][key] || this.declarationKinds["const"][key]) {
+    throw this.file.errorWithNode(id, "Duplicate declaration " + key, TypeError);
+  }
+};
+
+Scope.prototype.inferType = function (node) {
+  var target;
+
+  if (t.isVariableDeclarator(node)) {
+    target = node.init;
+  }
+
+  if (t.isLiteral(target) || t.isArrayExpression(target) || t.isObjectExpression(target)) {
+    // todo: possibly call some helper that will resolve these to a type annotation
+  }
+
+  if (t.isCallExpression(target)) {
+    // todo: need to resolve this to a return type
+  }
+
+  if (t.isMemberExpression(target)) {
+    // todo: crawl this and find the correct type, bail on anything that we cannot
+    // possibly be 100% confident on
+  }
+
+  if (t.isIdentifier(target)) {
+    return this.getType(target.name);
+  }
+};
+
+Scope.prototype.registerType = function (key, id, node) {
+  var type;
+
+  if (id.typeAnnotation) {
+    type = id.typeAnnotation;
+  }
+
+  if (!type) {
+    type = this.inferType(node);
+  }
+
+  if (type) {
+    if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
+    this.types[key] = type;
+  }
+};
+
+Scope.prototype.register = function (node, reference, kind) {
+  if (t.isVariableDeclaration(node)) {
+    return this.registerVariableDeclaration(node);
+  }
+
+  var ids = t.getBindingIdentifiers(node);
+
+  extend(this.references, ids);
+
+  if (reference) return;
+
+  for (var key in ids) {
+    var id = ids[key];
+
+    this.checkBlockScopedCollisions(key, id);
+
+    this.registerType(key, id, node);
+    this.bindings[key] = id;
+  }
+
+  var kinds = this.declarationKinds[kind];
+  if (kinds) extend(kinds, ids);
+};
+
+Scope.prototype.registerVariableDeclaration = function (declar) {
+  var declars = declar.declarations;
+  for (var i = 0; i < declars.length; i++) {
+    this.register(declars[i], false, declar.kind);
+  }
+};
+
 var functionVariableVisitor = {
   enter: function (node, parent, scope, context, state) {
     if (t.isFor(node)) {
       each(t.FOR_INIT_KEYS, function (key) {
         var declar = node[key];
-        if (t.isVar(declar)) state.add(declar);
+        if (t.isVar(declar)) state.scope.register(declar);
       });
     }
 
@@ -149,82 +224,69 @@ var functionVariableVisitor = {
     if (t.isExportDeclaration(node) && t.isDeclaration(node.declaration)) return;
 
     // we've ran into a declaration!
-    if (t.isDeclaration(node)) state.add(node);
+    if (t.isDeclaration(node)) state.scope.register(node);
   }
 };
 
 var programReferenceVisitor = {
-  enter: function (node, parent, scope, context, add) {
+  enter: function (node, parent, scope, context, state) {
     if (t.isReferencedIdentifier(node, parent) && !scope.hasReference(node.name)) {
-      add(node, true);
+      state.register(node, true);
     }
   }
 };
 
 var blockVariableVisitor = {
-  enter: function (node, parent, scope, context, add) {
+  enter: function (node, parent, scope, context, state) {
     if (t.isBlockScoped(node)) {
-      add(node, false);
+      state.register(node);
     } else if (t.isScope(node)) {
       context.skip();
     }
   }
 };
 
-Scope.prototype.getInfo = function () {
+Scope.prototype.crawl = function () {
   var parent = this.parent;
   var block  = this.block;
-  var self   = this;
-  if (block._scopeInfo) return block._scopeInfo;
+  var i;
 
-  var info = block._scopeInfo = {};
+  //
 
-  var bindings         = info.bindings         = object();
-  var references       = info.references       = object();
-  var types            = info.types            = object();
-  var declarationKinds = info.declarationKinds = {
-    "const": object(),
-    "var":   object(),
-    "let":   object()
+  var info = block._scopeInfo;
+  if (info) {
+    extend(this, info);
+    return;
+  }
+
+  info = block._scopeInfo = {
+    declarationKinds: {
+      "const": object(),
+      "var":   object(),
+      "let":   object()
+    },
+
+    references: object(),
+    bindings:   object(),
+    types:      object(),
   };
 
-  var add = function (node, reference) {
-    var ids = t.getBindingIdentifiers(node);
+  extend(this, info);
 
-    extend(references, ids);
-
-    if (!reference) {
-      for (var key in ids) {
-        var id = ids[key];
-
-        if (id.typeAnnotation) {
-          types[id] = id.typeAnnotation;
-        }
-
-        if (declarationKinds["let"][key] || declarationKinds["const"][key]) {
-          throw self.file.errorWithNode(id, "Duplicate declaration " + key, TypeError);
-        }
-      }
-
-      extend(bindings, ids);
-
-      var kinds = declarationKinds[node.kind];
-      if (kinds) extend(kinds, ids);
-    }
-  };
+  //
 
   if (parent && t.isBlockStatement(block) && t.isLoop(parent.block, { body: block })) {
     // delegate let bindings to the parent loop
-    return info;
+    return;
   }
 
   // ForStatement - left, init
 
   if (t.isLoop(block)) {
-    each(t.FOR_INIT_KEYS, function (key) {
-      var node = block[key];
-      if (t.isBlockScoped(node)) add(node, false, true);
-    });
+    for (i = 0; i < t.FOR_INIT_KEYS.length; i++) {
+      var node = block[t.FOR_INIT_KEYS[i]];
+      if (t.isBlockScoped(node)) this.register(node, false, true);
+    }
 
     if (t.isBlockStatement(block.body)) {
       block = block.body;
@@ -234,19 +296,27 @@ Scope.prototype.getInfo = function () {
   // Program, BlockStatement - let variables
 
   if (t.isBlockStatement(block) || t.isProgram(block)) {
-    traverse(block, blockVariableVisitor, this, add);
+    traverse(block, blockVariableVisitor, this, this);
   }
 
   // CatchClause - param
 
   if (t.isCatchClause(block)) {
-    add(block.param);
+    this.register(block.param);
   }
 
   // ComprehensionExpression - blocks
 
   if (t.isComprehensionExpression(block)) {
-    add(block);
+    this.register(block);
+  }
+
+  // Function - params, rest
+
+  if (t.isFunction(block)) {
+    for (i = 0; i < block.params.length; i++) {
+      this.register(block.params[i]);
+    }
   }
 
   // Program, Function - var variables
@@ -254,7 +324,7 @@ Scope.prototype.getInfo = function () {
   if (t.isProgram(block) || t.isFunction(block)) {
     traverse(block, functionVariableVisitor, this, {
       blockId: block.id,
-      add:     add
+      scope:   this
     });
   }
 
@@ -262,25 +332,15 @@ Scope.prototype.getInfo = function () {
     if (!t.isProperty(this.parentBlock, { method: true })) {
       // SpiderMonkey AST doesn't use MethodDefinition here when it probably
       // should since they should be semantically the same?
-      add(block.id);
+      this.register(block.id);
     }
   }
 
   // Program
 
   if (t.isProgram(block)) {
-    traverse(block, programReferenceVisitor, this, add);
+    traverse(block, programReferenceVisitor, this, this);
   }
-
-  // Function - params, rest
-
-  if (t.isFunction(block)) {
-    each(block.params, function (param) {
-      add(param);
-    });
-  }
-
-  return info;
 };
 
 /**

lib/6to5/types/index.js

@@ -127,9 +127,7 @@ t.toComputedKey = function (node, key) {
 };
 
 /*
- * Shallowly checks to see if the passed `node` will evaluate to a
- * falsy. This is if `node` is a `Literal` and `value` is falsy or
- * `node` is an `Identifier` with a name of `undefiend`.
+ * Shallowly checks to see if the passed `node` is falsy.
  *
  * @param {Object} node
  * @returns {Boolean}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "3.3.5",
+  "version": "3.3.8",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://6to5.org/",
   "repository": "6to5/6to5",
@@ -9,6 +9,7 @@
   "main": "lib/6to5/index.js",
   "bin": {
     "6to5": "./bin/6to5/index.js",
+    "6to5-minify": "./bin/6to5-minify",
     "6to5-node": "./bin/6to5-node",
     "6to5-runtime": "./bin/6to5-runtime"
   },

packages/6to5-runtime/package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5-runtime",
   "description": "6to5 selfContained runtime",
-  "version": "3.3.4",
+  "version": "3.3.7",
   "repository": "6to5/6to5",
   "author": "Sebastian McKenzie <sebmck@gmail.com>"
 }

test/fixtures/transformation/es6-classes/super-class-id-member-expression/expected.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _classSuperConstructorCall = function (instance, Constructor) { if (Object.getPrototypeOf(Constructor) !== null) { Object.getPrototypeOf(Constructor).apply(instance, arguments); } };
-
 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
 
 var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
@@ -10,7 +8,9 @@ var BaseController = (function (_Chaplin$Controller) {
   function BaseController() {
     _classCallCheck(this, BaseController);
 
-    _classSuperConstructorCall(this, BaseController);
+    if (Object.getPrototypeOf(BaseController) !== null) {
+      Object.getPrototypeOf(BaseController).apply(this, arguments);
+    }
   }
 
   _inherits(BaseController, _Chaplin$Controller);
@@ -22,10 +22,12 @@ var BaseController2 = (function (_Chaplin$Controller$Another) {
   function BaseController2() {
     _classCallCheck(this, BaseController2);
 
-    _classSuperConstructorCall(this, BaseController2);
+    if (Object.getPrototypeOf(BaseController2) !== null) {
+      Object.getPrototypeOf(BaseController2).apply(this, arguments);
+    }
   }
 
   _inherits(BaseController2, _Chaplin$Controller$Another);
 
   return BaseController2;
-})(Chaplin.Controller.Another);
+})(Chaplin.Controller.Another);

test/fixtures/transformation/es6-classes/super-class/expected.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _classSuperConstructorCall = function (instance, Constructor) { if (Object.getPrototypeOf(Constructor) !== null) { Object.getPrototypeOf(Constructor).apply(instance, arguments); } };
-
 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
 
 var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
@@ -10,10 +8,12 @@ var Test = (function (Foo) {
   function Test() {
     _classCallCheck(this, Test);
 
-    _classSuperConstructorCall(this, Test);
+    if (Object.getPrototypeOf(Test) !== null) {
+      Object.getPrototypeOf(Test).apply(this, arguments);
+    }
   }
 
   _inherits(Test, Foo);
 
   return Test;
-})(Foo);
+})(Foo);

test/fixtures/transformation/spec-proto-to-assign/class/expected.js

@@ -2,8 +2,6 @@
 
 var _defaults = function (obj, defaults) { for (var key in defaults) { if (obj[key] === undefined) { obj[key] = defaults[key]; } } return obj; };
 
-var _classSuperConstructorCall = function (instance, Constructor) { if (Object.getPrototypeOf(Constructor) !== null) { Object.getPrototypeOf(Constructor).apply(instance, arguments); } };
-
 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _defaults(subClass, superClass); };
 
 var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
@@ -12,10 +10,12 @@ var Foo = (function (Bar) {
   function Foo() {
     _classCallCheck(this, Foo);
 
-    _classSuperConstructorCall(this, Foo);
+    if (Object.getPrototypeOf(Foo) !== null) {
+      Object.getPrototypeOf(Foo).apply(this, arguments);
+    }
   }
 
   _inherits(Foo, Bar);
 
   return Foo;
-})(Bar);
+})(Bar);