v1.13.3

Conflicts:
	lib/6to5/polyfill.js

CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.13.3
+
+ * Upgrade `acorn-6to5`.
+ * Add experimental support for abstract references.
+
 # 1.13.2
 
  * Optimise `Array.from` usage by adding a helper method.

README.md

@@ -4,7 +4,7 @@
 
 <p align="center">
   <a href="https://travis-ci.org/6to5/6to5">
-    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5.svg?branch=master&amp;style=flat&amp;label=travis">
+    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
   </a>
 
   <a href="https://ci.appveyor.com/project/sebmck/6to5">
@@ -26,4 +26,5 @@
 
 **6to5** turns ES6+ code into vanilla ES5, so you can use next generation features **today.**
 
-For more information view the [documentation](https://6to5.github.io).
+For more information view the [documentation](https://6to5.github.io). For
+support visit the [gitter room](https://gitter.im/6to5/6to5).

bin/_6to5-node

@@ -30,7 +30,11 @@ to5.register({
 //
 
 var _eval = function (code, filename) {
-  code = to5.transform(code, { filename: filename, blacklist: ["useStrict"] }).code;
+  code = to5.transform(code, {
+    filename: filename,
+    blacklist: ["useStrict"],
+    experimental: commander.experimental
+  }).code;
   return vm.runInThisContext(code, filename);
 };
 

doc/caveats.md

@@ -1,19 +1,17 @@
 # Caveats
 
-## Async/Generators
+In order for certain features to work they require certain polyfills. You can
+satisfy **all** 6to5 feature requirements by using the included
+[polyfill](polyfill.md). You may alternatively selectively include what you need:
 
-The [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js)
-and an [ES6 polyfill](polyfill.md) are required in order for generators to work.
-
-### Async/Comprehensions
-
-[Experimental support](usage.md#experimental) must be enabled for these proposed
-ES7 features to work.
-
-### Array comprehension/Array destructuring/Spread
-
-An [ES6 polyfill](polyfill.md) is required. More specifically a polyfill for
-`Array.isArray` and `Array.from`.
+| Feature                     | Requirements                                                                                                                        |
+| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| Abstract References         | `Symbol`                                                                                                                            |
+| Array destructuring         | `Array.isArray`, `Array.from`                                                                                                       |
+| Async functions, Generators | [experimental option](usage.md#experimental), [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) |
+| Comprehensions              | [experimental option](usage.md#experimental), `Array.isArray`, `Array.from`                                                         |
+| For..Of                     | `Symbol`, `prototype[Symbol.iterator]`                                                                                              |
+| Spread                      | `Array.isArray`, `Array.from`                                                                                                       |
 
 ## Classes
 
@@ -40,14 +38,3 @@ class Bar extends Foo {
   }
 }
 ```
-
-## Constructor spread
-
-Constructor spreads do not currently support built-ins. ie.
-`new Array(...items)`.
-
-## For-of
-
-A polyfill is required for for-of functionality that implements `Symbol` and
-adds `prototype[Symbol.iterator]` behaviour to built-ins. Using the polyfills
-specified in [polyfill](polyfill.md) suffices.

doc/differences.md

@@ -62,13 +62,14 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | ---------------------------- | ---- | ------- | -------------- | ------ | ------ | ----------- |
 | Source maps                  | ✓    | ✓       | ✓              | ✓      |        | ✓           |
 | No compiler global pollution | ✓    |         | ✓              | ✓      |        | ✓           |
-| No runtime                   | ✓    |         | ✓              |        |        | ✓           |
+| Optional runtime             | ✓    |         | ✓              |        |        | ✓           |
 | Browser support              | ✓    | ✓       |                | ✓      |        |             |
 
 ### Language Support
 
 |                              | 6to5  | Traceur | es6-transpiler | esnext | es6now | jstransform |
 | ---------------------------- | ----- | ------- | -------------- | ------ | ------ | ----------- |
+| Abstract references          | ✓     |         |                |        |        |             |
 | Array comprehension          | ✓     | ✓       | ✓              |        |        |             |
 | Arrow functions              | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Async functions              | ✓     | ✓       |                | ✓      |        |             |
@@ -89,10 +90,6 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | Template literals            | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Unicode regex                | ✓     | ✓       | ✓              |        |        |             |
 
-
-
-
-
 ### [Traceur](https://github.com/google/traceur-compiler)
 
 Traceur requires quite a bulky runtime (~75KB) and produces quite verbose code.

doc/features.md

@@ -1,5 +1,13 @@
 # Features
 
+## Abstract references ([experimental](usage.md#experimental)) ([spec](https://github.com/zenparsing/es-abstract-refs))
+
+```javascript
+foo::bar;
+foo::bar = baz;
+delete foo::bar;
+```
+
 ## Array comprehension ([experimental](usage.md#experimental))
 
 ```javascript
@@ -31,7 +39,7 @@ var bob = {
 };
 ```
 
-## Async functions ([experimental](usage.md#experimental))
+## Async functions ([experimental](usage.md#experimental)) ([spec](https://github.com/lukehoban/ecmascript-asyncawait))
 
 ```javascript
 async function chainAnimationsAsync(elem, animations) {

doc/index.md

@@ -31,6 +31,7 @@ And it doesn't end here! To see all the ways you can use 6to5, check out the
 
 ## [Features](features.md)
 
+ - [Abstract references](features.md#abstract-references) ([experimental](usage.md#experimental))
  - [Array comprehension](features.md#array-comprehension) ([experimental](usage.md#experimental))
  - [Async functions](features.md#async-functions) ([experimental](usage.md#experimental))
  - [Arrow functions](features.md#arrow-functions)

doc/polyfill.md

@@ -5,13 +5,23 @@
 [es6-shim](https://github.com/paulmillr/es6-shim) and
 [es6-symbol](https://github.com/medikoo/es6-symbol) polyfills.
 
-## Node
+This will emulate a full ES6 environment. This polyfill is automatically loaded
+when using [6to5-node](usage.md#node).
+
+## Usage
+
+### Node
+
+You need to include the polyfill require at the top the **entry point** to your
+application.
 
 ```javascript
 require("6to5/polyfill");
 ```
 
-## Browser
+### Browser
 
 Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release.
+npm release. This needs to be included **before** all your compiled 6to5 code.
+You can either prepend it to your compiled code or include it in a `<script>`
+before it.

doc/usage.md

@@ -192,4 +192,5 @@ require("6to5/register")({
 the `experimental: true` option when using the [Node API](#node) or
 `--experimental` when using the [CLI](#cli).
 
-**NOTE:** That these are subject to change as their proposal status progresses.
+**WARNING:** These proposals are subject to change so use with
+**extreme caution**.

lib/6to5/file.js

@@ -73,6 +73,8 @@ File.normaliseOptions = function (opts) {
 File.prototype.toArray = function (node) {
   if (t.isArrayExpression(node)) {
     return node;
+  } else if (t.isIdentifier(node) && node.name === "arguments") {
+    return t.callExpression(t.memberExpression(this.addDeclaration("slice"), t.identifier("call")), [node]);
   } else {
     return t.callExpression(this.addDeclaration("to-array"), [node]);
   }

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

@@ -9,6 +9,12 @@ exports.SpreadElement = function (node, print) {
   print(node.argument);
 };
 
+exports.VirtualPropertyExpression = function (node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.property);
+};
+
 exports.ObjectExpression =
 exports.ObjectPattern = function (node, print) {
   var props = node.properties;

lib/6to5/generation/node/index.js

@@ -24,15 +24,7 @@ function Node(node, parent) {
 }
 
 Node.prototype.isUserWhitespacable = function () {
-  var parent = this.parent;
-  var node = this.node;
-
-  if (t.isUserWhitespacable(node) ||
-      t.isSequenceExpression(parent)) {
-    return true;
-  }
-
-  return false;
+  return t.isUserWhitespacable(this.node);
 };
 
 Node.prototype.needsWhitespace = function (type) {

lib/6to5/polyfill.js

@@ -1,6 +1,37 @@
+/* jshint newcap: false */
+
+var ensureSymbol = function (key) {
+  Symbol[key] = Symbol[key] || Symbol();
+};
+
+var ensureProto = function (Constructor, key, val) {
+  var proto = Constructor.prototype;
+  proto[key] = proto[key] || val;
+};
+
+//
+
 if (typeof Symbol === "undefined") {
   require("es6-symbol/implement");
 }
 
 require("es6-shim");
-require("./transformation/transformers/generators/runtime");
+require("./transformation/transformers/es6-generators/runtime");
+
+// Abstract references
+
+ensureSymbol("referenceGet");
+ensureSymbol("referenceSet");
+ensureSymbol("referenceDelete");
+
+ensureProto(Function, Symbol.referenceGet, function () { return this; });
+
+ensureProto(Map, Symbol.referenceGet, Map.prototype.get);
+ensureProto(Map, Symbol.referenceSet, Map.prototype.set);
+ensureProto(Map, Symbol.referenceDelete, Map.prototype.delete);
+
+if (global.WeakMap) {
+  ensureProto(WeakMap, Symbol.referenceGet, WeakMap.prototype.get);
+  ensureProto(WeakMap, Symbol.referenceSet, WeakMap.prototype.set);
+  ensureProto(WeakMap, Symbol.referenceDelete, WeakMap.prototype.delete);
+}

lib/6to5/templates/abstract-expression-call.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT).call(OBJECT)

lib/6to5/templates/abstract-expression-delete.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceDelete](OBJECT)

lib/6to5/templates/abstract-expression-get.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT)

lib/6to5/templates/abstract-expression-set.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceSet](OBJECT, VALUE)

lib/6to5/transformation/transform.js

@@ -28,30 +28,31 @@ transform.moduleFormatters = {
 };
 
 _.each({
-  modules:                   require("./transformers/modules"),
-  propertyNameShorthand:     require("./transformers/property-name-shorthand"),
-  arrayComprehension:        require("./transformers/array-comprehension"),
-  generatorComprehension:    require("./transformers/generator-comprehension"),
-  arrowFunctions:            require("./transformers/arrow-functions"),
-  classes:                   require("./transformers/classes"),
+  modules:                   require("./transformers/es6-modules"),
+  propertyNameShorthand:     require("./transformers/es6-property-name-shorthand"),
+  arrayComprehension:        require("./transformers/es7-array-comprehension"),
+  generatorComprehension:    require("./transformers/es7-generator-comprehension"),
+  arrowFunctions:            require("./transformers/es6-arrow-functions"),
+  classes:                   require("./transformers/es6-classes"),
 
   _propertyLiterals:         require("./transformers/_property-literals"),
-  computedPropertyNames:     require("./transformers/computed-property-names"),
+  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
 
-  spread:                    require("./transformers/spread"),
-  templateLiterals:          require("./transformers/template-literals"),
-  propertyMethodAssignment:  require("./transformers/property-method-assignment"),
-  defaultParameters:         require("./transformers/default-parameters"),
-  restParameters:            require("./transformers/rest-parameters"),
-  destructuring:             require("./transformers/destructuring"),
-  forOf:                     require("./transformers/for-of"),
-  unicodeRegex:              require("./transformers/unicode-regex"),
+  spread:                    require("./transformers/es6-spread"),
+  templateLiterals:          require("./transformers/es6-template-literals"),
+  propertyMethodAssignment:  require("./transformers/es5-property-method-assignment"),
+  defaultParameters:         require("./transformers/es6-default-parameters"),
+  restParameters:            require("./transformers/es6-rest-parameters"),
+  destructuring:             require("./transformers/es6-destructuring"),
+  forOf:                     require("./transformers/es6-for-of"),
+  unicodeRegex:              require("./transformers/es6-unicode-regex"),
+  abstractReferences:        require("./transformers/es7-abstract-references"),
   react:                     require("./transformers/react"),
 
-  constants:                 require("./transformers/constants"),
-  letScoping:                require("./transformers/let-scoping"),
+  constants:                 require("./transformers/es6-constants"),
+  letScoping:                require("./transformers/es6-let-scoping"),
 
-  generators:                require("./transformers/generators"),
+  generators:                require("./transformers/es6-generators"),
 
   _blockHoist:               require("./transformers/_block-hoist"),
   _declarations:             require("./transformers/_declarations"),

lib/6to5/transformation/transformers/es7-abstract-references.js

@@ -0,0 +1,60 @@
+// https://github.com/zenparsing/es-abstract-refs
+
+var util = require("../../util");
+var t    = require("../../types");
+
+var container = function (parent, call, ret) {
+  if (t.isExpressionStatement(parent)) {
+    // we don't need to worry about return values
+    return call;
+  } else {
+    return t.sequenceExpression([call, ret]);
+  }
+};
+
+exports.AssignmentExpression = function (node, parent) {
+  var left = node.left;
+  if (!t.isVirtualPropertyExpression(left)) return;
+
+  var right = node.right;
+
+  var call = util.template("abstract-expression-set", {
+    PROPERTY: left.property,
+    OBJECT:   left.object,
+    VALUE:    right
+  });
+
+  return container(parent, call, right);
+};
+
+exports.UnaryExpression = function (node, parent) {
+  var arg = node.argument;
+  if (!t.isVirtualPropertyExpression(arg)) return;
+  if (node.operator !== "delete") return;
+
+  var call = util.template("abstract-expression-delete", {
+    PROPERTY: arg.property,
+    OBJECT:   arg.object
+  });
+
+  return container(parent, call, t.literal(true));
+};
+
+exports.CallExpression = function (node) {
+  var callee = node.callee;
+  if (!t.isVirtualPropertyExpression(callee)) return;
+
+  var call = util.template("abstract-expression-call", {
+    PROPERTY: callee.property,
+    OBJECT:   callee.object
+  });
+  call.arguments = call.arguments.concat(node.arguments);
+  return call;
+};
+
+exports.VirtualPropertyExpression = function (node) {
+  return util.template("abstract-expression-get", {
+    PROPERTY: node.property,
+    OBJECT:   node.object
+  });
+};

lib/6to5/transformation/transformers/es7-generator-comprehension.js

@@ -1,4 +1,4 @@
-var arrayComprehension = require("./array-comprehension");
+var arrayComprehension = require("./es7-array-comprehension");
 var t                  = require("../../types");
 
 exports.ComprehensionExpression = function (node) {

lib/6to5/types/visitor-keys.json

@@ -1,76 +1,77 @@
 {
-  "ArrayExpression":          ["elements"],
-  "ArrayPattern":             ["elements"],
-  "ArrowFunctionExpression":  ["params", "defaults", "rest", "body"],
-  "AssignmentExpression":     ["left", "right"],
-  "AwaitExpression":          ["argument"],
-  "BinaryExpression":         ["left", "right"],
-  "BlockStatement":           ["body"],
-  "BreakStatement":           ["label"],
-  "CallExpression":           ["callee", "arguments"],
-  "CatchClause":              ["param", "body"],
-  "ClassBody":                ["body"],
-  "ClassDeclaration":         ["id", "body", "superClass"],
-  "ClassExpression":          ["id", "body", "superClass"],
-  "ComprehensionBlock":       ["left", "right", "body"],
-  "ComprehensionExpression":  ["filter", "blocks", "body"],
-  "ConditionalExpression":    ["test", "consequent", "alternate"],
-  "ContinueStatement":        ["label"],
-  "DebuggerStatement":        [],
-  "DoWhileStatement":         ["body", "test"],
-  "EmptyStatement":           [],
-  "ExportBatchSpecifier":     [],
-  "ExportDeclaration":        ["declaration", "specifiers", "source"],
-  "ExportSpecifier":          ["id", "name"],
-  "ExpressionStatement":      ["expression"],
-  "File":                     ["program"],
-  "ForInStatement":           ["left", "right", "body"],
-  "ForOfStatement":           ["left", "right", "body"],
-  "ForStatement":             ["init", "test", "update", "body"],
-  "FunctionDeclaration":      ["id", "params", "defaults", "rest", "body"],
-  "FunctionExpression":       ["id", "params", "defaults", "rest", "body"],
-  "Identifier":               [],
-  "IfStatement":              ["test", "consequent", "alternate"],
-  "ImportBatchSpecifier":     ["id"],
-  "ImportDeclaration":        ["specifiers", "source"],
-  "ImportSpecifier":          ["id", "name"],
-  "LabeledStatement":         ["label", "body"],
-  "Literal":                  [],
-  "LogicalExpression":        ["left", "right"],
-  "MemberExpression":         ["object", "property"],
-  "MethodDefinition":         ["key", "value"],
-  "NewExpression":            ["callee", "arguments"],
-  "ObjectExpression":         ["properties"],
-  "ObjectPattern":            ["properties"],
-  "ParenthesizedExpression":  ["expression"],
-  "Program":                  ["body"],
-  "Property":                 ["key", "value"],
-  "ReturnStatement":          ["argument"],
-  "SequenceExpression":       ["expressions"],
-  "SpreadElement":            ["argument"],
-  "SwitchCase":               ["test", "consequent"],
-  "SwitchStatement":          ["discriminant", "cases"],
-  "TaggedTemplateExpression": ["tag", "quasi"],
-  "TemplateElement":          [],
-  "TemplateLiteral":          ["quasis", "expressions"],
-  "ThisExpression":           [],
-  "ThrowStatement":           ["argument"],
-  "TryStatement":             ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
-  "UnaryExpression":          ["argument"],
-  "UpdateExpression":         ["argument"],
-  "VariableDeclaration":      ["declarations"],
-  "VariableDeclarator":       ["id", "init"],
-  "WhileStatement":           ["test", "body"],
-  "WithStatement":            ["object", "body"],
-  "XJSAttribute":             ["name", "value"],
-  "XJSClosingElement":        ["name"],
-  "XJSElement":               ["openingElement", "closingElement", "children"],
-  "XJSEmptyExpression":       [],
-  "XJSExpressionContainer":   ["expression"],
-  "XJSIdentifier":            [],
-  "XJSMemberExpression":      ["object", "property"],
-  "XJSNamespacedName":        ["namespace", "name"],
-  "XJSOpeningElement":        ["name", "attributes"],
-  "XJSSpreadAttribute":       ["argument"],
-  "YieldExpression":          ["argument"]
+  "ArrayExpression":           ["elements"],
+  "ArrayPattern":              ["elements"],
+  "ArrowFunctionExpression":   ["params", "defaults", "rest", "body"],
+  "AssignmentExpression":      ["left", "right"],
+  "AwaitExpression":           ["argument"],
+  "BinaryExpression":          ["left", "right"],
+  "BlockStatement":            ["body"],
+  "BreakStatement":            ["label"],
+  "CallExpression":            ["callee", "arguments"],
+  "CatchClause":               ["param", "body"],
+  "ClassBody":                 ["body"],
+  "ClassDeclaration":          ["id", "body", "superClass"],
+  "ClassExpression":           ["id", "body", "superClass"],
+  "ComprehensionBlock":        ["left", "right", "body"],
+  "ComprehensionExpression":   ["filter", "blocks", "body"],
+  "ConditionalExpression":     ["test", "consequent", "alternate"],
+  "ContinueStatement":         ["label"],
+  "DebuggerStatement":         [],
+  "DoWhileStatement":          ["body", "test"],
+  "EmptyStatement":            [],
+  "ExportBatchSpecifier":      [],
+  "ExportDeclaration":         ["declaration", "specifiers", "source"],
+  "ExportSpecifier":           ["id", "name"],
+  "ExpressionStatement":       ["expression"],
+  "File":                      ["program"],
+  "ForInStatement":            ["left", "right", "body"],
+  "ForOfStatement":            ["left", "right", "body"],
+  "ForStatement":              ["init", "test", "update", "body"],
+  "FunctionDeclaration":       ["id", "params", "defaults", "rest", "body"],
+  "FunctionExpression":        ["id", "params", "defaults", "rest", "body"],
+  "Identifier":                [],
+  "IfStatement":               ["test", "consequent", "alternate"],
+  "ImportBatchSpecifier":      ["id"],
+  "ImportDeclaration":         ["specifiers", "source"],
+  "ImportSpecifier":           ["id", "name"],
+  "LabeledStatement":          ["label", "body"],
+  "Literal":                   [],
+  "LogicalExpression":         ["left", "right"],
+  "MemberExpression":          ["object", "property"],
+  "MethodDefinition":          ["key", "value"],
+  "NewExpression":             ["callee", "arguments"],
+  "ObjectExpression":          ["properties"],
+  "ObjectPattern":             ["properties"],
+  "ParenthesizedExpression":   ["expression"],
+  "Program":                   ["body"],
+  "Property":                  ["key", "value"],
+  "ReturnStatement":           ["argument"],
+  "SequenceExpression":        ["expressions"],
+  "SpreadElement":             ["argument"],
+  "SwitchCase":                ["test", "consequent"],
+  "SwitchStatement":           ["discriminant", "cases"],
+  "TaggedTemplateExpression":  ["tag", "quasi"],
+  "TemplateElement":           [],
+  "TemplateLiteral":           ["quasis", "expressions"],
+  "ThisExpression":            [],
+  "ThrowStatement":            ["argument"],
+  "TryStatement":              ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
+  "UnaryExpression":           ["argument"],
+  "UpdateExpression":          ["argument"],
+  "VariableDeclaration":       ["declarations"],
+  "VariableDeclarator":        ["id", "init"],
+  "VirtualPropertyExpression": ["left", "right"],
+  "WhileStatement":            ["test", "body"],
+  "WithStatement":             ["object", "body"],
+  "XJSAttribute":              ["name", "value"],
+  "XJSClosingElement":         ["name"],
+  "XJSElement":                ["openingElement", "closingElement", "children"],
+  "XJSEmptyExpression":        [],
+  "XJSExpressionContainer":    ["expression"],
+  "XJSIdentifier":             [],
+  "XJSMemberExpression":       ["object", "property"],
+  "XJSNamespacedName":         ["namespace", "name"],
+  "XJSOpeningElement":         ["name", "attributes"],
+  "XJSSpreadAttribute":        ["argument"],
+  "YieldExpression":           ["argument"]
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.13.2",
+  "version": "1.13.3",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -40,14 +40,14 @@
     "fs-readdir-recursive": "0.1.0",
     "lodash": "2.4.1",
     "mkdirp": "0.5.0",
-    "es6-shim": "0.20.3",
+    "es6-shim": "0.21.0",
     "es6-symbol": "0.1.1",
     "regexpu": "0.3.0",
     "source-map": "0.1.40",
     "chokidar": "0.11.1",
     "source-map-support": "0.2.8",
-    "esutils": "1.1.4",
-    "acorn-6to5": "0.9.1-4",
+    "esutils": "1.1.6",
+    "acorn-6to5": "0.9.1-5",
     "estraverse": "1.8.0",
     "private": "0.1.6"
   },

test/fixtures/generation/types/SequenceExpression/expected.js

@@ -1,4 +1,3 @@
 foo, bar;
 
-foo,
-bar;
+foo, bar;

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

@@ -1,9 +1,6 @@
 "use strict";
 
-var _toArray = function (arr) {
-  return Array.isArray(arr) ? arr : Array.from(arr);
-};
-
+var _slice = Array.prototype.slice;
 var _classProps = function (child, staticProps, instanceProps) {
   if (staticProps) Object.defineProperties(child, staticProps);
   if (instanceProps) Object.defineProperties(child.prototype, instanceProps);
@@ -28,11 +25,11 @@ var Test = (function (Foo) {
     Foo.prototype.test.call(this);
     foob(Foo);
 
-    Foo.call.apply(Foo, [this].concat(_toArray(arguments)));
-    Foo.call.apply(Foo, [this, "test"].concat(_toArray(arguments)));
+    Foo.call.apply(Foo, [this].concat(_slice.call(arguments)));
+    Foo.call.apply(Foo, [this, "test"].concat(_slice.call(arguments)));
 
-    Foo.prototype.test.call.apply(Foo.prototype, [this].concat(_toArray(arguments)));
-    Foo.prototype.test.call.apply(Foo.prototype, [this, "test"].concat(_toArray(arguments)));
+    Foo.prototype.test.call.apply(Foo.prototype, [this].concat(_slice.call(arguments)));
+    Foo.prototype.test.call.apply(Foo.prototype, [this, "test"].concat(_slice.call(arguments)));
   };
 
   _extends(Test, Foo);
@@ -42,8 +39,8 @@ var Test = (function (Foo) {
       writable: true,
       value: function () {
         Foo.foo.call(this);
-        Foo.foo.call.apply(Foo.foo, [this].concat(_toArray(arguments)));
-        Foo.foo.call.apply(Foo.foo, [this, "test"].concat(_toArray(arguments)));
+        Foo.foo.call.apply(Foo.foo, [this].concat(_slice.call(arguments)));
+        Foo.foo.call.apply(Foo.foo, [this, "test"].concat(_slice.call(arguments)));
       }
     }
   }, {
@@ -51,8 +48,8 @@ var Test = (function (Foo) {
       writable: true,
       value: function () {
         Foo.prototype.test.call(this);
-        Foo.prototype.test.call.apply(Foo.prototype.test, [this].concat(_toArray(arguments)));
-        Foo.prototype.test.call.apply(Foo.prototype.test, [this, "test"].concat(_toArray(arguments)));
+        Foo.prototype.test.call.apply(Foo.prototype.test, [this].concat(_slice.call(arguments)));
+        Foo.prototype.test.call.apply(Foo.prototype.test, [this, "test"].concat(_slice.call(arguments)));
       }
     }
   });