Reorganize sources.

src/utils/class.js

@@ -0,0 +1,67 @@
+/* Simple JavaScript Inheritance
+ * By John Resig http://ejohn.org/
+ * MIT Licensed.
+ * http://ejohn.org/blog/simple-javascript-inheritance/
+ */
+// Inspired by base2 and Prototype
+(function(){
+  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
+
+  // The base Class implementation (does nothing)
+  this.Class = function(){};
+  module.exports = Class;
+
+  // Create a new Class that inherits from this class
+  Class.extend = function(prop) {
+    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;
+
+    // Copy the properties over onto the new prototype
+    for (var name in prop) {
+      // 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;
+
+            // 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;
+
+            return ret;
+          };
+        })(name, prop[name]) :
+        prop[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);
+    }
+
+    // Populate our constructed prototype object
+    Class.prototype = prototype;
+
+    // Enforce the constructor to be what we expect
+    Class.prototype.constructor = Class;
+
+    // And make this class extendable
+    Class.extend = arguments.callee;
+
+    return Class;
+  };
+
+})();

src/utils/extend.js

@@ -0,0 +1,78 @@
+/**
+Plain JavaScript replacement of jQuery .extend based on jQuery sources.
+@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
+*/
+
+function _extend() {
+
+  function isPlainObject( obj ) {
+    if ((typeof obj !== "object") || obj.nodeType ||
+      (obj !== null && obj === obj.window)) {
+      return false;
+    }
+    if (obj.constructor &&
+      !hasOwnProperty.call( obj.constructor.prototype, "isPrototypeOf" )) {
+      return false;
+    }
+    return true;
+  }
+
+  var options
+    , name
+    , src
+    , copy
+    , copyIsArray
+    , clone
+    , target = arguments[0] || {}
+    , i = 1
+    , length = arguments.length
+    , deep = false;
+
+  // Handle a deep copy situation
+  if (typeof target === "boolean") {
+    deep = target;
+    // Skip the boolean and the target
+    target = arguments[i] || {};
+    i++;
+  }
+
+  // Handle case when target is a string or something (possible in deep copy)
+  //if (typeof target !== "object" && !jQuery.isFunction(target))
+  if (typeof target !== "object" && typeof target !== "function")
+    target = {};
+
+  for (; i < length; i++) {
+    // Only deal with non-null/undefined values
+    if ((options = arguments[i]) !== null) {
+      // Extend the base object
+      for (name in options) {
+        src = target[name];
+        copy = options[name];
+
+        // Prevent never-ending loop
+        if (target === copy) continue;
+
+        // Recurse if we're merging plain objects or arrays
+        if (deep && copy && (isPlainObject(copy) ||
+          (copyIsArray = (copy.constructor === Array)))) {
+          if (copyIsArray) {
+            copyIsArray = false;
+            clone = src && (src.constructor === Array) ? src : [];
+          } else {
+            clone = src && isPlainObject(src) ? src : {};
+          }
+          // Never move original objects, clone them
+          target[name] = _extend(deep, clone, copy);
+          // Don't bring in undefined values
+        } else if (copy !== undefined) {
+          target[name] = copy;
+        }
+      }
+    }
+  }
+
+  // Return the modified object
+  return target;
+}
+
+module.exports = _extend;