docs: function createConstructor(constructor, isAbstract) {
          var Instance = constructor || function Instance() {
              var x,
                  tmp;
  
              // Check if the user forgot the new keyword
              if (!(this instanceof Instance)) {
                  throw new Error('Constructor called as a function, use the new keyword instead.');
              }
  
              // If it's abstract, it cannot be instantiated
              if (isAbstract) {
                  throw new Error('An abstract class cannot be instantiated.');
              }
  
              obfuscateProperty(this, '$initializing', true, true, true);  // Mark it in order to let abstract classes run their initialize
              obfuscateProperty(this, '$super', null, true);               // Add the super to the instance object to speed lookup of the wrapper function
              obfuscateProperty(this, '$self', null, true);                // Add the self to the instance object to speed lookup of the wrapper function
  
              tmp = this.$static[$class];
  
              // Apply private/protected members
              if (hasDefineProperty) {
                  protectInstance(this);
              } else {
                  // Reset some types of the object in order for each instance to have their variables
                  for (x in tmp.properties) {
                      if (!tmp.properties[x].isImmutable) {
                          this[x] = deepClone(this[x]);
                      }
                  }
              }
  
              // Apply binds
              if (tmp.binds.length) {
                  applyBinds(tmp.binds, this, this);
              }
  
              delete this.$initializing;
  
              // Prevent any properties/methods to be added and deleted
              if (!tmp.forceUnlocked && tmp.locked && isFunction(Object.seal)) {
                  Object.seal(this);
              }
  
              // Call initialize
              this.initialize.apply(this, arguments);
          };
  
          if (!Instance[$class]) {
              obfuscateProperty(Instance, $class, { methods: {}, properties: {}, staticMethods: {}, staticProperties: {}, ownMembers: {}, interfaces: [], binds: [] });
              if (hasDefineProperty) {
                  Instance[$class].simpleConstructor = function () {};
                  obfuscateProperty(Instance[$class].simpleConstructor, '$constructor', Instance);
              }
          }
  
          return Instance;
      }