// The Base object constructor
  var Base = function(obj) {
      // Only work if there's something to extend
      if ( obj )
          // If used as Base(), use the prototype of the caller
          if ( this == window )
              Base.prototype.extend.call(obj, arguments.callee.prototype);
  
          // Otherwise, this is called as new Base(), so extend the object
          else
              this.extend(obj);
  };
  
  Base.version = "1.0.2";
  
  Base.prototype = {
      // A function for overriding one object property with another
      extend: function(source, value) {
          var extend = Base.prototype.extend;
  
          // Check to see if we're overriding a property with a new value
          if (arguments.length == 2) {
              // Remember the original parent property value
              var ancestor = this[source];
  
              // Check to see if we're overriding a parent method, and that this.base()
              // is actually used by the overrider
              if ((ancestor instanceof Function) && (value instanceof Function) &&
                  ancestor.valueOf() != value.valueOf() && /\bbase\b/.test(value)) {
  
                  // Remember the old function
                  var method = value;
  
                  // and build a new function wrapper, to have sane 
                  value = function() {
                      // Remember the old value of this.base to be restored later
                      var previous = this.base;
                      // Calling this.base() calls the old parent function
                      this.base = ancestor;
  
                      // Execute the new, overriding, function
                      var returnValue = method.apply(this, arguments);
  
                      // Restore the this.base() property
                      this.base = previous;
  
                      // Return the accurate return value
                      return returnValue;
                  };
  
                  // valueOf and toString get messed by our modified
                  // wrapper function, so make them appear normal
                  value.valueOf = function() { return method; };
                  value.toString = function() { return String(method); };
              }
  
              // Attach the new property to the source
              return this[source] = value;
  
          // If only a source was provided, copy all properties over from
          // the parent class to this new child
          } else if (source) {
              var _prototype = {toSource: null};
  
              // We modify these two functions later on, so protect them
              var _protected = ["toString", "valueOf"];
  
              // if we are prototyping then include the constructor
              if (Base._prototyping) _protected[2] = "constructor";
  
              // Copy over the protected functions indvidually
              for (var i = 0; (name = _protected[i]); i++)
                  if (source[name] != _prototype[name])
                      extend.call(this, name, source[name]);
  
              // Copy each of the source object's properties to this object
              for (var name in source)
                  if (!_prototype[name])
                      extend.call(this, name, source[name]);
          }
  
          return this;
      },
  
      // The this.base() function which we'll be implementating later on
      base: function() {}
  };
  
  // A wrapper function for creating a new object constructor
  Base.extend = function(_instance, _static) {
      // Remember the extend function
      var extend = Base.prototype.extend;
  
      // Lets us do Base.extend() and get a blank object constructor
      if (!_instance) _instance = {};
  
      // Make sure to include the constructor later
      Base._prototyping = true;
  
      // Build the prototype
      var _prototype = new this;
      extend.call(_prototype, _instance);
  
      // Build the constructor
      var constructor = _prototype.constructor;
      _prototype.constructor = this;
  
      delete Base._prototyping;
  
      // Create the wrapper for the constructor function
      var klass = function() {
          if (!Base._prototyping) constructor.apply(this, arguments);
          this.constructor = klass;
      };
  
      // Which inherits from Base
      klass.prototype = _prototype;
  
      // Add all the extra Base methods
      klass.extend = this.extend;
      klass.implement = this.implement;
      klass.toString = function() {
          return String(constructor);
      };
  
      // Add in all the extra properties provided by the user
      extend.call(klass, _static);
  
      // Check for a single instance case
      var object = constructor ? klass : _prototype;
  
      // Class initialisation
      if (object.init instanceof Function) object.init();
  
      // Return the new object constructor
      return object;
  };
  
  // A simple function that can be used to pull additional object properties
  // into a constructor – effectively creating multiple inheritance
  Base.implement = function(_interface) {
      // If a constructor was provided, instead of a prototype,
      // get the prototype instead
      if (_interface instanceof Function) _interface = _interface.prototype;
  
      // Extend the object with the methods from the parent object
      this.prototype.extend(_interface);
  };