updated code and added README usage

README.md

@@ -0,0 +1,9 @@
+# resig-class
+
+[http://ejohn.org/blog/simple-javascript-inheritance/](http://ejohn.org/blog/simple-javascript-inheritance/)
+
+## Usage
+
+```javascript
+const { Class } = require('resig-class');
+```

index.js

@@ -1,80 +1,73 @@
-/* Simple JavaScript Inheritance
- * By John Resig http://ejohn.org/
+/* Simple JavaScript Inheritance for ES 5.1
+ * based on http://ejohn.org/blog/simple-javascript-inheritance/
+ *  (inspired by base2 and Prototype)
  * MIT Licensed.
  */
-// Inspired by base2 and Prototype
+(function (global) {
+  'use strict';
+  var fnTest = /xyz/.test(function () {
+    xyz;
+  })
+    ? /\b_super\b/
+    : /.*/;
 
-(function (root, factory) {
-  if (typeof define === 'function' && define.amd) {
-    // AMD. Register as an anonymous module.
-    define([], function () {
-      return (root.Class = factory());
-    });
-  } else if (typeof module === 'object' && module.exports) {
-    // Node. Does not work with strict CommonJS, but
-    // only CommonJS-like environments that support module.exports,
-    // like Node.
-    module.exports = factory();
-  } else {
-    // Browser globals
-    root.Class = factory();
-  }
-}(this, function () {
-  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
   // The base Class implementation (does nothing)
-  this.Class = function(){};
+  function BaseClass() {}
 
   // Create a new Class that inherits from this class
-  Class.extend = function(prop) {
+  BaseClass.extend = function (props) {
     var _super = this.prototype;
 
-    // Instantiate a base class (but only create the instance,
-    // don't run the init constructor)
-    initializing = true;
-    var prototype = new this();
-    initializing = false;
+    // Set up the prototype to inherit from the base class
+    // (but without running the init constructor)
+    var proto = Object.create(_super);
 
     // Copy the properties over onto the new prototype
-    for (var name in prop) {
+    for (var name in props) {
       // Check if we're overwriting an existing function
-      prototype[name] = typeof prop[name] == "function" &&
-      typeof _super[name] == "function" && fnTest.test(prop[name]) ?
-          (function(name, fn){
-            return function() {
-              var tmp = this._super;
+      proto[name] =
+        typeof props[name] === 'function' && typeof _super[name] == 'function' && fnTest.test(props[name])
+          ? (function (name, fn) {
+              return function () {
+                var tmp = this._super;
 
-              // Add a new ._super() method that is the same method
-              // but on the super-class
-              this._super = _super[name];
+                // Add a new ._super() method that is the same method
+                // but on the super-class
+                this._super = _super[name];
 
-              // The method only need to be bound temporarily, so we
-              // remove it when we're done executing
-              var ret = fn.apply(this, arguments);
-              this._super = tmp;
+                // The method only need to be bound temporarily, so we
+                // remove it when we're done executing
+                var ret = fn.apply(this, arguments);
+                this._super = tmp;
 
-              return ret;
-            };
-          })(name, prop[name]) :
-          prop[name];
+                return ret;
+              };
+            })(name, props[name])
+          : props[name];
     }
 
-    // The dummy class constructor
-    function Class() {
-      // All construction is actually done in the init method
-      if ( !initializing && this.init )
-        this.init.apply(this, arguments);
-    }
+    // The new constructor
+    var newClass =
+      typeof proto.init === 'function'
+        ? proto.hasOwnProperty('init')
+          ? proto.init // All construction is actually done in the init method
+          : function SubClass() {
+              _super.init.apply(this, arguments);
+            }
+        : function EmptyClass() {};
 
     // Populate our constructed prototype object
-    Class.prototype = prototype;
+    newClass.prototype = proto;
 
     // Enforce the constructor to be what we expect
-    Class.constructor = Class;
+    proto.constructor = newClass;
 
     // And make this class extendable
-    Class.extend = arguments.callee;
+    newClass.extend = BaseClass.extend;
 
-    return Class;
+    return newClass;
   };
-  return Class;
-}));
+
+  // export
+  global.Class = BaseClass;
+})(this);

package.json

@@ -2,7 +2,7 @@
   "author": "Matt Insler <matt.insler@gmail.com>",
   "name": "resig-class",
   "description": "http://ejohn.org/blog/simple-javascript-inheritance/",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/mattinsler/resig-class.git"
@@ -12,4 +12,4 @@
   },
   "dependencies": {},
   "devDependencies": {}
-}
+}