docs: function (name, staticProperties, instanceProperties) {
  		var shortName = name,
  			klass = staticProperties,
  			proto = instanceProperties;
  
  		// Figure out what was passed and normalize it.
  		if (typeof shortName !== 'string') {
  			proto = klass;
  			klass = shortName;
  			shortName = null;
  		}
  		if (!proto) {
  			proto = klass;
  			klass = null;
  		}
  		proto = proto || {};
  		var _super_class = this,
  			_super = this.prototype,
  			Constructor, prototype;
  		// Instantiate a base class (but only create the instance,
  		// don't run the init constructor).
  		prototype = this.instance();
  		// Copy the properties over onto the new prototype.
  		Construct._inherit(proto, _super, prototype);
  
  		if(shortName) {
  
  		} else if(klass && klass.shortName) {
  			shortName = klass.shortName;
  		} else if(this.shortName) {
  			shortName = this.shortName;
  		}
  		// We want constructor.name to be the same as shortName, within
  		// the bounds of what the JS VM will allow (meaning no non-word characters).
  		// new Function() is significantly faster than eval() here.
  
  		// Strip semicolons
  		//!steal-remove-start
  		// wrapping this var will cause "used out of scope." when linting
  		var constructorName = shortName ? shortName.replace(constructorNameRegex, '_') : 'Constructor';
  		if(process.env.NODE_ENV !== 'production') {
  			if(reservedWords[constructorName]) {
  				constructorName = CanString.capitalize(constructorName);
  			}
  		}
  		//!steal-remove-end
  
  		// The dummy class constructor.
  		function init() {
  			/* jshint validthis: true */
  			// All construction is actually done in the init method.
  			if (!initializing) {
  				//!steal-remove-start
  				if(process.env.NODE_ENV !== 'production') {
  					if(!this || (this.constructor !== Constructor) &&
  					// We are being called without `new` or we are extending.
  					arguments.length && Constructor.constructorExtends) {
  						dev.warn('can/construct/construct.js: extending a Construct without calling extend');
  					}
  				}
  				//!steal-remove-end
  
  				return (!this || this.constructor !== Constructor) &&
  				// We are being called without `new` or we are extending.
  				arguments.length && Constructor.constructorExtends ? Constructor.extend.apply(Constructor, arguments) :
  				// We are being called with `new`.
  				Constructor.newInstance.apply(Constructor, arguments);
  			}
  		}
  		Constructor = typeof namedCtor === "function" ?
  			namedCtor( constructorName, init ) :
  			function() { return init.apply(this, arguments); };
  
  		// Copy old stuff onto class (can probably be merged w/ inherit)
  		for (var propName in _super_class) {
  			if (_super_class.hasOwnProperty(propName)) {
  				Constructor[propName] = _super_class[propName];
  			}
  		}
  		// Copy new static properties on class.
  		Construct._inherit(klass, _super_class, Constructor);
  
  		// Set things that shouldn't be overwritten.
  		canReflect.assignMap(Constructor, {
  			constructor: Constructor,
  			prototype: prototype
  			/**
  			 * @property {String} can-construct.shortName shortName
  			 * @parent can-construct.static
  			 *
  			 * If you pass a name when creating a Construct, the `shortName` property will be set to the
  			 * name.
  			 *
  			 * ```js
  			 * var MyConstructor = Construct.extend("MyConstructor",{},{});
  			 * MyConstructor.shortName // "MyConstructor"
  			 * ```
  			 */
  		});
  
  		if (shortName !== undefined) {
  			if (Object.getOwnPropertyDescriptor) {
  				var desc = Object.getOwnPropertyDescriptor(Constructor, 'name');
  				if (!desc || desc.configurable) {
  					Object.defineProperty(
  						Constructor,
  						'name',
  						{ writable: true, value: shortName, configurable: true }
  					);
  				}
  			}
  			Constructor.shortName = shortName;
  		}
  		// Make sure our prototype looks nice.
  		defineNonEnumerable(Constructor.prototype, "constructor", Constructor);
  		// Call the class `setup` and `init`
  		var t = [_super_class].concat(Array.prototype.slice.call(arguments)),
  			args = Constructor.setup.apply(Constructor, t);
  		if (Constructor.init) {
  			Constructor.init.apply(Constructor, args || t);
  		}
  		/**
  		 * @prototype
  		 */
  		return Constructor; //
  		/**
  		 * @property {Object} can-construct.prototype.constructor constructor
  		 * @parent can-construct.prototype
  		 *
  		 * A reference to the constructor function that created the instance. This allows you to access
  		 * the constructor's static properties from an instance.
  		 *
  		 * @body
  		 * ## Example
  		 *
  		 * This Construct has a static counter that counts how many instances have been created:
  		 *
  		 * ```js
  		 * var Counter = Construct.extend({
  		 *     count: 0
  		 * }, {
  		 *     init: function() {
  		 *         this.constructor.count++;
  		 *     }
  		 * });
  		 *
  		 * var childCounter = new Counter();
  		 * console.log(childCounter.constructor.count); // 1
  		 * console.log(Counter.count); // 1
  		 * ```
  		 */
  	}