condenser 0.0.4 → 0.0.5

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/NamedClassExpressionWithinVariableDeclaration/actual.js

@@ -0,0 +1,5 @@
+let Apple = class Banana extends Fruit {
+  tastiness() {
+    return 7;
+  }
+}

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/NamedClassExpressionWithinVariableDeclaration/expected.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require("babel-runtime/helpers/inherits");
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var __babelPluginTransformClassInheritedHook = function __babelPluginTransformClassInheritedHook(child, parent, childName) {
+  if (childName) {
+    Object.defineProperty(child, "name", {
+      value: childName,
+      configurable: true
+    });
+  }
+
+  if ("onInherited" in parent) {
+    if (typeof parent.onInherited == 'function') {
+      var returnedNewChild = parent.onInherited(child);
+
+      if (returnedNewChild !== void 0) {
+        if (childName && typeof returnedNewChild == 'function' && returnedNewChild.name !== childName) {
+          Object.defineProperty(returnedNewChild, "name", {
+            value: childName,
+            configurable: true
+          });
+        }
+
+        child = returnedNewChild;
+      }
+    } else {
+      throw new TypeError("Attempted to call onInherited, but it was not a function");
+    }
+  }
+
+  return child;
+};
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Apple = function () {
+  var _Banana = function (_Fruit) {
+    (0, _inherits3.default)(_Banana, _Fruit);
+
+    function _Banana() {
+      (0, _classCallCheck3.default)(this, _Banana);
+      return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(_Banana).apply(this, arguments));
+    }
+
+    (0, _createClass3.default)(_Banana, [{
+      key: "tastiness",
+      value: function tastiness() {
+        return 7;
+      }
+    }]);
+    return _Banana;
+  }(Fruit);
+
+  return __babelPluginTransformClassInheritedHook(_Banana, Fruit, "Banana");
+}();

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/SuperClassAsObjectProperty/actual.js

@@ -0,0 +1,10 @@
+let Fruits = {
+  Apple: class Apple {},
+  Banana: class {}
+};
+
+class RedDelicious extends Fruits.Apple {
+  redness() {
+    return 46;
+  }
+}

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/SuperClassAsObjectProperty/expected.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require("babel-runtime/helpers/inherits");
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var __babelPluginTransformClassInheritedHook = function __babelPluginTransformClassInheritedHook(child, parent, childName) {
+  if (childName) {
+    Object.defineProperty(child, "name", {
+      value: childName,
+      configurable: true
+    });
+  }
+
+  if ("onInherited" in parent) {
+    if (typeof parent.onInherited == 'function') {
+      var returnedNewChild = parent.onInherited(child);
+
+      if (returnedNewChild !== void 0) {
+        if (childName && typeof returnedNewChild == 'function' && returnedNewChild.name !== childName) {
+          Object.defineProperty(returnedNewChild, "name", {
+            value: childName,
+            configurable: true
+          });
+        }
+
+        child = returnedNewChild;
+      }
+    } else {
+      throw new TypeError("Attempted to call onInherited, but it was not a function");
+    }
+  }
+
+  return child;
+};
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Fruits = {
+  Apple: function Apple() {
+    (0, _classCallCheck3.default)(this, Apple);
+  },
+  Banana: function Banana() {
+    (0, _classCallCheck3.default)(this, Banana);
+  }
+};
+
+var RedDelicious = function () {
+  var _RedDelicious = function (_Fruits$Apple) {
+    (0, _inherits3.default)(_RedDelicious, _Fruits$Apple);
+
+    function _RedDelicious() {
+      (0, _classCallCheck3.default)(this, _RedDelicious);
+      return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(_RedDelicious).apply(this, arguments));
+    }
+
+    (0, _createClass3.default)(_RedDelicious, [{
+      key: "redness",
+      value: function redness() {
+        return 46;
+      }
+    }]);
+    return _RedDelicious;
+  }(Fruits.Apple);
+
+  return __babelPluginTransformClassInheritedHook(_RedDelicious, Fruits.Apple, "RedDelicious");
+}();

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/UnnamedDefaultExportClassDeclaration/actual.js

@@ -0,0 +1,5 @@
+export default class extends Fruit {
+  tastiness() {
+    return 7;
+  }
+}

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/fixtures/UnnamedDefaultExportClassDeclaration/expected.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require("babel-runtime/helpers/inherits");
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var __babelPluginTransformClassInheritedHook = function __babelPluginTransformClassInheritedHook(child, parent, childName) {
+  if (childName) {
+    Object.defineProperty(child, "name", {
+      value: childName,
+      configurable: true
+    });
+  }
+
+  if ("onInherited" in parent) {
+    if (typeof parent.onInherited == 'function') {
+      var returnedNewChild = parent.onInherited(child);
+
+      if (returnedNewChild !== void 0) {
+        if (childName && typeof returnedNewChild == 'function' && returnedNewChild.name !== childName) {
+          Object.defineProperty(returnedNewChild, "name", {
+            value: childName,
+            configurable: true
+          });
+        }
+
+        child = returnedNewChild;
+      }
+    } else {
+      throw new TypeError("Attempted to call onInherited, but it was not a function");
+    }
+  }
+
+  return child;
+};
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _class = function () {
+  var _class2 = function (_Fruit) {
+    (0, _inherits3.default)(_class2, _Fruit);
+
+    function _class2() {
+      (0, _classCallCheck3.default)(this, _class2);
+      return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(_class2).apply(this, arguments));
+    }
+
+    (0, _createClass3.default)(_class2, [{
+      key: "tastiness",
+      value: function tastiness() {
+        return 7;
+      }
+    }]);
+    return _class2;
+  }(Fruit);
+
+  return __babelPluginTransformClassInheritedHook(_class2, Fruit, "_class");
+}();
+
+exports.default = _class;

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/index.js

@@ -0,0 +1,107 @@
+var assert = require('assert');
+var babel = require('babel-core');
+var clear = require('clear');
+var diff = require('diff');
+var fs = require('fs');
+var jsonfile = require('jsonfile');
+var path = require('path');
+var Mocha = require('mocha');
+
+require('babel-register');
+
+var pluginPath = require.resolve('../src');
+
+function runTests() {
+	var testsPath = __dirname + '/fixtures/';
+
+	fs.readdirSync(testsPath).map(function(item) {
+		return {
+			path: path.join(testsPath, item),
+			name: item,
+		};
+	}).filter(function(item) {
+		return fs.statSync(item.path).isDirectory();
+	}).forEach(runTest);
+
+	runMocha();
+}
+
+function runMocha() {
+	// Instantiate a Mocha instance.
+	var mocha = new Mocha();
+
+	var testDir = path.join(__dirname, 'mocha')
+
+	var suite = path.join(testDir, 'suite.js')
+
+	var output = babel.transformFileSync(suite, {
+		plugins: [pluginPath]
+	});
+
+	var suiteCompiled = path.join(testDir, '.suite_compiled.js');
+
+	fs.writeFileSync(suiteCompiled, output.code);
+
+	delete require.cache[require.resolve(suiteCompiled)];
+
+	mocha.addFile(suiteCompiled);
+
+	// Run the tests.
+	mocha.run();
+}
+
+function runTest(dir) {
+	var babelOptions = {
+		plugins: [pluginPath]
+	}
+
+	babelRcPath = path.join(dir.path, '.babelrc');
+	try {
+		fs.accessSync(babelRcPath);
+		babelOptions = jsonfile.readFileSync(babelRcPath);
+	} catch(e) {}
+
+	var output = babel.transformFileSync(dir.path + '/actual.js', babelOptions);
+
+	var expected = fs.readFileSync(dir.path + '/expected.js', 'utf-8');
+
+	function normalizeLines(str) {
+		return str.trimRight().replace(/\r\n/g, '\n');
+	}
+
+	process.stdout.write(dir.name);
+	process.stdout.write('\n\n');
+
+	diff.diffLines(normalizeLines(output.code), normalizeLines(expected))
+	.forEach(function (part) {
+		var value = part.value;
+		if (part.added) {
+			value = part.value;
+		} else if (part.removed) {
+			value = part.value;
+		}
+
+
+		process.stdout.write(value);
+	});
+
+	process.stdout.write('\n\n\n');
+}
+
+if (process.argv.indexOf('--watch') >= 0) {
+	require('watch').watchTree(__dirname + '/..', {
+		ignoreDotFiles: true
+	}, function () {
+		delete require.cache[pluginPath];
+		clear();
+		console.log('Press Ctrl+C to stop watching...');
+		console.log('================================');
+		try {
+			runTests();
+		} catch (e) {
+			console.error(e.stack);
+		}
+	});
+} else {
+	runTests();
+}

data/lib/condenser/processors/node_modules/babel-plugin-transform-class-extended-hook/test/mocha/suite.js

@@ -0,0 +1,2190 @@
+import 'mocha';
+import * as assert from 'assert';
+
+describe("Class.extended", function() {
+    describe("is called when a class is extended", function() {
+        it("using named class declarations", function() {
+            let child = null;
+
+            class Parent {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            }
+
+            class Child extends Parent {}
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using anonymous class expressions with variable declaration", function() {
+            let child = null;
+
+            let Parent = class {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            };
+
+            let Child = class extends Parent {};
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using named class expressions saved as variables", function() {
+            let child = null;
+
+            let Parent = class NamedParent {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            };
+
+            let Child = class NamedChild extends Parent {};
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using anonymous class expressions on object literal properties", function() {
+            let child = null;
+
+            let Parents = {
+                Parent: class {
+                    static extended(inheritor) {
+                        child = inheritor;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class extends Parents.Parent {}
+            }
+
+            assert.strictEqual(child, Children.Child);
+        });
+
+        it("using named class expressions on object literal properties", function() {
+            let child = null;
+
+            let Parents = {
+                Parent: class NamedParent {
+                    static extended(inheritor) {
+                        child = inheritor;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class NamedChild extends Parents.Parent {}
+            }
+
+            assert.strictEqual(child, Children.Child);
+        });
+    });
+
+    describe("is called when a class is inherited from (down the chain)", function() {
+        it("using named class declarations", function() {
+            let child = null;
+
+            class Grandparent {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            }
+
+            class Parent extends Grandparent {}
+
+            class Child extends Parent {}
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using anonymous class expressions with variable declaration", function() {
+            let child = null;
+
+            let Grandparent = class {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            };
+
+            let Parent = class extends Grandparent {};
+
+            let Child = class extends Parent {};
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using named class expressions saved as variables", function() {
+            let child = null;
+
+            let Grandparent = class NamedGrandparent {
+                static extended(inheritor) {
+                    child = inheritor;
+                }
+            };
+
+            let Parent = class NamedParent extends Grandparent {};
+
+            let Child = class NamedChild extends Parent {};
+
+            assert.strictEqual(child, Child);
+        });
+
+        it("using anonymous class expressions on object literal properties", function() {
+            let child = null;
+
+            let Grandparents = {
+                Grandparent: class {
+                    static extended(inheritor) {
+                        child = inheritor;
+                    }
+                }
+            };
+
+            let Parents = {
+                Parent: class extends Grandparents.Grandparent {}
+            };
+
+            let Children = {
+                Child: class extends Parents.Parent {}
+            };
+
+            assert.strictEqual(child, Children.Child);
+        });
+
+        it("using named class expressions on object literal properties", function() {
+            let child = null;
+
+            let Grandparents = {
+                Grandparent: class NamedGrandparent {
+                    static extended(inheritor) {
+                        child = inheritor;
+                    }
+                }
+            };
+
+            let Parents = {
+                Parent: class NamedParent extends Grandparents.Grandparent {}
+            };
+
+            let Children = {
+                Child: class NamedChild extends Parents.Parent {}
+            };
+
+            assert.strictEqual(child, Children.Child);
+        });
+    });
+    describe("can be overriden by an intermediate class in the prototype chain", function() {
+        it("using named class declarations", function() {
+            let calledWith = [];
+
+            class Grandparent {
+                static extended(inheritor) {
+                    calledWith.push(inheritor);
+                }
+            }
+
+            class Parent extends Grandparent {
+                static extended(inheritor) {}
+            }
+
+            class Child extends Parent {}
+
+            assert.deepStrictEqual(calledWith, [Parent]);
+        });
+
+        it("using anonymous class expressions with variable declaration", function() {
+            let calledWith = [];
+
+            let Grandparent = class {
+                static extended(inheritor) {
+                    calledWith.push(inheritor);
+                }
+            };
+
+            let Parent = class extends Grandparent {
+                static extended(inheritor) {}
+            };
+
+            let Child = class extends Parent {};
+
+            assert.deepStrictEqual(calledWith, [Parent]);
+        });
+
+        it("using named class expressions saved as variables", function() {
+            let calledWith = [];
+
+            let Grandparent = class NamedGrandparent {
+                static extended(inheritor) {
+                    calledWith.push(inheritor);
+                }
+            };
+
+            let Parent = class NamedParent extends Grandparent {
+                static extended(inheritor) {}
+            };
+
+            let Child = class NamedChild extends Parent {};
+
+            assert.deepStrictEqual(calledWith, [Parent]);
+        });
+
+        it("using anonymous class expressions on object literal properties", function() {
+            let calledWith = [];
+
+            let Grandparents = {
+                Grandparent: class {
+                    static extended(inheritor) {
+                        calledWith.push(inheritor);
+                    }
+                }
+            };
+
+            let Parents = {
+                Parent: class extends Grandparents.Grandparent {
+                    static extended(inheritor) {}
+                }
+            };
+
+            let Children = {
+                Child: class extends Parents.Parent {}
+            }
+
+            assert.deepStrictEqual(calledWith, [Parents.Parent]);
+        });
+
+        it("using named class expressions on object literal properties", function() {
+            let calledWith = [];
+
+            let Grandparents = {
+                Grandparent: class NamedGrandparent {
+                    static extended(inheritor) {
+                        calledWith.push(inheritor);
+                    }
+                }
+            };
+
+            let Parents = {
+                Parent: class NamedParent extends Grandparents.Grandparent {
+                    static extended(inheritor) {}
+                }
+            };
+
+            let Children = {
+                Child: class NamedChild extends Parents.Parent {}
+            }
+
+            assert.deepStrictEqual(calledWith, [Parents.Parent]);
+        });
+    });
+
+    describe("can redefine the value of the declared class", function() {
+        it("using named class declarations", function() {
+            let replacement = {};
+
+            class Parent {
+                static extended(inheritor) {
+                    return replacement;
+                }
+            }
+
+            class Child extends Parent {}
+
+            assert.strictEqual(Child, replacement);
+        });
+
+        it("using anonymous class expressions with variable declaration", function() {
+            let replacement = {};
+
+            let Parent = class {
+                static extended(inheritor) {
+                    return replacement;
+                }
+            };
+
+            let Child = class extends Parent {};
+
+            assert.strictEqual(Child, replacement);
+        });
+
+        it("using named class expressions saved as variables", function() {
+            let replacement = {};
+
+            let Parent = class NamedParent {
+                static extended(inheritor) {
+                    return replacement;
+                }
+            };
+
+            let Child = class NamedChild extends Parent {};
+
+            assert.strictEqual(Child, replacement);
+        });
+
+        it("using anonymous class expressions on object literal properties", function() {
+            let replacement = {};
+
+            let Parents = {
+                Parent: class {
+                    static extended(inheritor) {
+                        return replacement;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class extends Parents.Parent {}
+            }
+
+            assert.strictEqual(Children.Child, replacement);
+        });
+
+        it("using named class expressions on object literal properties", function() {
+            let replacement = {};
+
+            let Parents = {
+                Parent: class NamedParent {
+                    static extended(inheritor) {
+                        return replacement;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class NamedChild extends Parents.Parent {}
+            }
+
+            assert.strictEqual(Children.Child, replacement);
+        });
+    });
+
+    describe("can redefine the value of the declared class to a falsy value other than undefined", function() {
+        describe("null", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {
+                        return null;
+                    }
+                }
+
+                class Child extends Parent {}
+
+                assert.strictEqual(Child, null);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {
+                        return null;
+                    }
+                };
+
+                let Child = class extends Parent {};
+
+                assert.strictEqual(Child, null);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {
+                        return null;
+                    }
+                };
+
+                let Child = class NamedChild extends Parent {};
+
+                assert.strictEqual(Child, null);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {
+                            return null;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                }
+
+                assert.strictEqual(Children.Child, null);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {
+                            return null;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                }
+
+                assert.strictEqual(Children.Child, null);
+            });
+        });
+
+        describe("0", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {
+                        return 0;
+                    }
+                }
+
+                class Child extends Parent {}
+
+                assert.strictEqual(Child, 0);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {
+                        return 0;
+                    }
+                };
+
+                let Child = class extends Parent {};
+
+                assert.strictEqual(Child, 0);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {
+                        return 0;
+                    }
+                };
+
+                let Child = class NamedChild extends Parent {};
+
+                assert.strictEqual(Child, 0);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {
+                            return 0;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                }
+
+                assert.strictEqual(Children.Child, 0);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {
+                            return 0;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                }
+
+                assert.strictEqual(Children.Child, 0);
+            });
+        });
+
+        describe("\"\" (empty string)", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {
+                        return "";
+                    }
+                }
+
+                class Child extends Parent {}
+
+                assert.equal(Child, "");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {
+                        return "";
+                    }
+                };
+
+                let Child = class extends Parent {};
+
+                assert.equal(Child, "");
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {
+                        return "";
+                    }
+                };
+
+                let Child = class NamedChild extends Parent {};
+
+                assert.equal(Child, "");
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {
+                            return "";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                }
+
+                assert.equal(Children.Child, "");
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {
+                            return "";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                }
+
+                assert.equal(Children.Child, "");
+            });
+        });
+
+        describe("false", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {
+                        return false;
+                    }
+                }
+
+                class Child extends Parent {}
+
+                assert.equal(Child, false);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {
+                        return false;
+                    }
+                };
+
+                let Child = class extends Parent {};
+
+                assert.equal(Child, false);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {
+                        return false;
+                    }
+                };
+
+                let Child = class NamedChild extends Parent {};
+
+                assert.equal(Child, false);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {
+                            return false;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                }
+
+                assert.equal(Children.Child, false);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {
+                            return false;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                }
+
+                assert.equal(Children.Child, false);
+            });
+        });
+
+        describe("NaN", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {
+                        return NaN;
+                    }
+                }
+
+                class Child extends Parent {}
+
+                assert.ok(isNaN(Child));
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {
+                        return NaN;
+                    }
+                };
+
+                let Child = class extends Parent {};
+
+                assert.ok(isNaN(Child));
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {
+                        return NaN;
+                    }
+                };
+
+                let Child = class NamedChild extends Parent {};
+
+                assert.ok(isNaN(Child));
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {
+                            return NaN;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                }
+
+                assert.ok(isNaN(Children.Child));
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {
+                            return NaN;
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                }
+
+                assert.ok(isNaN(Children.Child));
+            });
+        });
+    });
+
+    describe("can not redefine the value of the declared class by returning undefined", function() {
+        it("using named class declarations", function() {
+            class Parent {
+                static extended(inheritor) {
+                    return undefined;
+                }
+            }
+
+            class Child extends Parent {}
+
+            assert.notEqual(Child, undefined)
+        });
+
+        it("using anonymous class expressions with variable declaration", function() {
+            let Parent = class {
+                static extended(inheritor) {
+                    return undefined;
+                }
+            };
+
+            let Child = class extends Parent {};
+
+            assert.notEqual(Child, undefined)
+        });
+
+        it("using named class expressions saved as variables", function() {
+            let Parent = class NamedParent {
+                static extended(inheritor) {
+                    return undefined;
+                }
+            };
+
+            let Child = class NamedChild extends Parent {};
+
+            assert.notEqual(Child, undefined)
+        });
+
+        it("using anonymous class expressions on object literal properties", function() {
+            let Parents = {
+                Parent: class {
+                    static extended(inheritor) {
+                        return undefined;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class extends Parents.Parent {}
+            }
+
+            assert.notEqual(Children.Child, undefined)
+        });
+
+        it("using named class expressions on object literal properties", function() {
+            let Parents = {
+                Parent: class NamedParent {
+                    static extended(inheritor) {
+                        return undefined;
+                    }
+                }
+            };
+
+            let Children = {
+                Child: class NamedChild extends Parents.Parent {}
+            }
+
+            assert.notEqual(Children.Child, undefined)
+        });
+    });
+});
+
+
+
+describe("A class", function() {
+    describe("with no parent", function() {
+        describe("has a reliable name property", function() {
+            it("using named class declarations", function() {
+                class Thing {}
+                assert.equal(Thing.name, "Thing");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {};
+                assert.equal(Thing.name, "Thing")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {};
+                assert.equal(Thing.name, "NamedThing")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {}
+                }
+                assert.equal(Things.Thing.name, "NamedThing")
+            });
+        });
+        describe("can have static methods", function() {
+            it("using named class declarations", function() {
+                class Thing {
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                }
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class {
+                        static coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(Things.Thing.coolnessFactor(), 5);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {
+                        static coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(Things.Thing.coolnessFactor(), 5);
+            });
+        });
+        describe("can have instance methods", function() {
+            it("using named class declarations", function() {
+                class Thing {
+                    coolnessFactor() {
+                        return 5;
+                    }
+                }
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {
+                    coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {
+                    coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class {
+                        coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(new Things.Thing().coolnessFactor(), 5);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {
+                        coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(new Things.Thing().coolnessFactor(), 5);
+            });
+        });
+    });
+    describe("with no parent that defines a static extended method", function() {
+        describe("has a reliable name property", function() {
+            it("using named class declarations", function() {
+                class Thing {
+                    static extended(inheritor) {}
+                }
+                assert.equal(Thing.name, "Thing")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {
+                    static extended(inheritor) {}
+                };
+                assert.equal(Thing.name, "Thing")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {
+                    static extended(inheritor) {}
+                };
+                assert.equal(Thing.name, "NamedThing")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {
+                        static extended(inheritor) {}
+                    }
+                }
+                assert.equal(Things.Thing.name, "NamedThing")
+            });
+        });
+        describe("can have static methods", function() {
+            it("using named class declarations", function() {
+                class Thing {
+                    static extended(inheritor) {}
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                }
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {
+                    static extended(inheritor) {}
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {
+                    static extended(inheritor) {}
+                    static coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(Thing.coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class {
+                        static extended(inheritor) {}
+                        static coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(Things.Thing.coolnessFactor(), 5);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {
+                        static extended(inheritor) {}
+                        static coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(Things.Thing.coolnessFactor(), 5);
+            });
+        });
+        describe("can have instance methods", function() {
+            it("using named class declarations", function() {
+                class Thing {
+                    static extended(inheritor) {}
+                    coolnessFactor() {
+                        return 5;
+                    }
+                }
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Thing = class {
+                    static extended(inheritor) {}
+                    coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Thing = class NamedThing {
+                    static extended(inheritor) {}
+                    coolnessFactor() {
+                        return 5;
+                    }
+                };
+                assert.equal(new Thing().coolnessFactor(), 5);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class {
+                        static extended(inheritor) {}
+                        coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(new Things.Thing().coolnessFactor(), 5);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Things = {
+                    Thing: class NamedThing {
+                        static extended(inheritor) {}
+                        coolnessFactor() {
+                            return 5;
+                        }
+                    }
+                }
+                assert.equal(new Things.Thing().coolnessFactor(), 5);
+            });
+        });
+    });
+    describe("with a parent", function() {
+        describe("has a reliable name property", function() {
+            it("using named class declarations", function() {
+                class Parent {}
+                class Child extends Parent {}
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {};
+                let Child = class extends Parent {};
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {};
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.name, "NamedChild")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.name, "NamedChild")
+            });
+        });
+        describe("can have static methods", function() {
+            it("using named class declarations", function() {
+                class Parent {}
+                class Child extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(Child.childishness(), 6);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {};
+                let Child = class extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {};
+                let Child = class NamedChild extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6);
+            });
+        });
+        describe("can inherit static methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+        });
+        describe("can have instance methods", function() {
+            it("using named class declarations", function() {
+                class Parent {}
+                class Child extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {};
+                let Child = class extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {};
+                let Child = class NamedChild extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+        });
+        describe("can inherit instance methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    eyeColor() {
+                        return "brown";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class extends Parent {};
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().eyeColor(), "brown");
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().eyeColor(), "brown");
+            });
+        });
+    });
+    describe("with a parent that declares a static extended method", function() {
+        describe("has a reliable name property", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {}
+                }
+                class Child extends Parent {}
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {}
+                };
+                let Child = class extends Parent {};
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {}
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.name, "NamedChild")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.name, "NamedChild")
+            });
+        });
+        describe("can have static methods", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {}
+                }
+                class Child extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {}
+                };
+                let Child = class extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {}
+                };
+                let Child = class NamedChild extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6)
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6)
+            });
+        });
+        describe("can inherit static methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {}
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {}
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+        });
+        describe("can have instance methods", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {}
+                }
+                class Child extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {}
+                };
+                let Child = class extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {}
+                };
+                let Child = class NamedChild extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+        });
+        describe("can inherit instance methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Parent {
+                    static extended(inheritor) {}
+                    eyeColor() {
+                        return "brown";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Parent = class {
+                    static extended(inheritor) {}
+                    eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class extends Parent {};
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Parent = class NamedParent {
+                    static extended(inheritor) {}
+                    eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(new Child().eyeColor(), "brown");
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class {
+                        static extended(inheritor) {}
+                        eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().eyeColor(), "brown");
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Parents = {
+                    Parent: class NamedParent {
+                        static extended(inheritor) {}
+                        eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().eyeColor(), "brown");
+            });
+        });
+    });
+    describe("with a grandparent that declares a static extended method", function() {
+        describe("has a reliable name property", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                }
+                class Parent extends Grandparent {}
+                class Child extends Parent {}
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                };
+                let Parent = class extends Grandparent {};
+                let Child = class extends Parent {};
+                assert.equal(Child.name, "Child")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                };
+                let Parent = class NamedParent extends Grandparent {};
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.name, "NamedChild")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.name, "NamedChild")
+            });
+        });
+        describe("can have static methods", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                }
+                class Parent extends Grandparent {}
+                class Child extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                };
+                let Parent = class extends Grandparent {};
+                let Child = class extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                };
+                let Parent = class NamedParent extends Grandparent {};
+                let Child = class NamedChild extends Parent {
+                    static childishness() {
+                        return 6;
+                    }
+                };
+                assert.equal(Child.childishness(), 6)
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6)
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        static childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(Children.Child.childishness(), 6)
+            });
+        });
+        describe("can inherit static methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                }
+
+                class Parent extends Grandparent {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class extends Grandparent {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class NamedParent extends Grandparent {
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+        });
+        describe("can inherit static methods from its grandparent", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                }
+
+                class Parent extends Grandparent {}
+                class Child extends Parent {}
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+
+                let Parent = class extends Grandparent {};
+                let Child = class extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                    static eyeColor() {
+                        return "brown";
+                    }
+                };
+
+                let Parent = class NamedParent extends Grandparent {};
+                let Child = class NamedChild extends Parent {};
+                assert.equal(Child.eyeColor(), "brown")
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                        static eyeColor() {
+                            return "brown";
+                        }
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(Children.Child.eyeColor(), "brown")
+            });
+        });
+        describe("can have instance methods", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                }
+
+                class Parent extends Grandparent {}
+                class Child extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class extends Grandparent {};
+                let Child = class extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class NamedParent extends Grandparent {};
+                let Child = class NamedChild extends Parent {
+                    childishness() {
+                        return 6;
+                    }
+                }
+                assert.equal(new Child().childishness(), 6);
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {
+                        childishness() {
+                            return 6;
+                        }
+                    }
+                };
+                assert.equal(new Children.Child().childishness(), 6);
+            });
+        });
+        describe("can inherit instance methods from its parent", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                }
+
+                class Parent extends Grandparent {
+                    hairColor() {
+                        return "red";
+                    }
+                }
+                class Child extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class extends Grandparent {
+                    hairColor() {
+                        return "red";
+                    }
+                };
+                let Child = class extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                };
+
+                let Parent = class NamedParent extends Grandparent {
+                    hairColor() {
+                        return "red";
+                    }
+                };
+                let Child = class NamedChild extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {
+                        hairColor() {
+                            return "red";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().hairColor(), "red");
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {
+                        hairColor() {
+                            return "red";
+                        }
+                    }
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().hairColor(), "red");
+            });
+        });
+        describe("can inherit instance methods from its grandparent", function() {
+            it("using named class declarations", function() {
+                class Grandparent {
+                    static extended(inheritor) {}
+                    hairColor() {
+                        return "red";
+                    }
+                }
+
+                class Parent extends Grandparent {}
+                class Child extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using anonymous class expressions with variable declaration", function() {
+                let Grandparent = class {
+                    static extended(inheritor) {}
+                    hairColor() {
+                        return "red";
+                    }
+                };
+
+                let Parent = class extends Grandparent {};
+                let Child = class extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using named class expressions saved as variables", function() {
+                let Grandparent = class NamedGrandparent {
+                    static extended(inheritor) {}
+                    hairColor() {
+                        return "red";
+                    }
+                };
+
+                let Parent = class NamedParent extends Grandparent {};
+                let Child = class NamedChild extends Parent {}
+                assert.equal(new Child().hairColor(), "red");
+            });
+
+            it("using anonymous class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class {
+                        static extended(inheritor) {}
+                        hairColor() {
+                            return "red";
+                        }
+                    }
+                };
+
+                let Parents = {
+                    Parent: class extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().hairColor(), "red");
+            });
+
+            it("using named class expressions on object literal properties", function() {
+                let Grandparents = {
+                    Grandparent: class NamedGrandparent {
+                        static extended(inheritor) {}
+                        hairColor() {
+                            return "red";
+                        }
+                    }
+                };
+
+                let Parents = {
+                    Parent: class NamedParent extends Grandparents.Grandparent {}
+                };
+
+                let Children = {
+                    Child: class NamedChild extends Parents.Parent {}
+                };
+                assert.equal(new Children.Child().hairColor(), "red");
+            });
+        });
+    });
+});