docs: function extend(extendedClassName, prototypeAdditions) {
      switch (arguments.length) {
          case 0:
              prototypeAdditions = {};
              break;
          case 1:
              switch (typeof extendedClassName) {
                  case 'object':
                      prototypeAdditions = extendedClassName;
                      extendedClassName = undefined;
                      break;
                  case 'string':
                      prototypeAdditions = {};
                      break;
                  default:
                      throw 'Single-parameter overload must be either string or object.';
              }
              break;
          case 2:
              if (typeof extendedClassName !== 'string' || typeof prototypeAdditions !== 'object') {
                  throw 'Two-parameter overload must be string, object.';
              }
              break;
          default:
              throw 'Too many parameters';
      }
  
      /**
       * @class
       */
      function Constructor() {
          if (this.preInitialize) {
              this.preInitialize.apply(this, arguments);
          }
  
          initializePrototypeChain.apply(this, arguments);
  
          if (this.postInitialize) {
              this.postInitialize.apply(this, arguments);
          }
      }
  
      /**
       * @method
       * @see {@link extend-me.extend}
       * @desc Added to each returned extended class constructor.
       */
      Constructor.extend = extend;
  
      Constructor.getClassName = getClassName;
  
      /**
       * @method
       * @param {string} [ancestorConstructorName] - If given, searches up the prototype chain for constructor with matching name.
       * @returns {function|null} Constructor of parent class; or ancestor class with matching name; or null
       */
      Constructor.parent = parentConstructor;
  
      var prototype = Constructor.prototype = Object.create(this.prototype);
      prototype.constructor = Constructor;
  
      extendedClassName = extendedClassName || prototype.$$CLASS_NAME || prototype.name;
      if (extendedClassName) {
          Object.defineProperty(Constructor, 'name', { value: extendedClassName, configurable: true });
          prototype.$$CLASS_NAME = extendedClassName;
      }
  
      // define each prototype addition on the prototype (including getter/setters)
      var key, descriptor;
      for (key in prototypeAdditions) {
          if ((descriptor = Object.getOwnPropertyDescriptor(prototypeAdditions, key))) {
              Object.defineProperty(prototype, key, descriptor);
          }
      }
  
      if (typeof this.postExtend === 'function') {
          this.postExtend(prototype);
      }
  
      return Constructor;
  }