docs: function parseBorrows(params, constructor) {
          if (hasOwn(params, '$borrows')) {
              var current,
                  mixins = toArray(params.$borrows),
                  i = mixins.length,
                  key,
                  opts = {};
  
              // Verify argument type
              if (!i && !isArray(params.$borrows)) {
                  throw new Error('$borrows of class "' + constructor.prototype.$name + '" must be a class/object or an array of classes/objects.');
              }
              // Verify duplicate entries
              if (i !== unique(mixins).length && compact(mixins).length === i) {
                  throw new Error('There are duplicate entries defined in $borrows of class "' + constructor.prototype.$name + '".');
              }
  
              for (i -= 1; i >= 0; i -= 1) {
                  current = mixins[i];
  
                  // If is a vanilla object
                  if (isObject(current)) {
                      if (current.$static) {
                          throw new Error('Entry at index ' + i + ' in $borrows of class "' + constructor.prototype.$name + '" is not a valid class/object.');
                      }
                      borrowFromVanilla(current, constructor);
                      continue;
                  }
                  // If is a vanilla class
                  if (isFunction(current) && !current[$interface]) {
                      if (!current[$class]) {
                          borrowFromVanilla(current.prototype, constructor);
                          continue;
                      }
                  } else {
                      throw new Error('Entry at index ' + i + ' in $borrows of class "' + constructor.prototype.$name + '" is not a valid class/object.');
                  }
  
                  current = current.prototype;
  
                  // Verify if is an abstract class with unimplemented members
                  if (current.$static[$abstract] && current.$static[$abstract].unimplemented) {
                      throw new Error('Entry at index ' + i + ' in $borrows of class "' + constructor.prototype.$name + '" is an abstract class with abstract members, which are not allowed.');
                  }
  
                  // Verify if it has parent
                  if (current.$static.$parent) {
                      throw new Error('Entry at index ' + i + ' in $borrows of class "' + constructor.prototype.$name + '" is an inherited class (only root classes are supported).');
                  }
  
                  delete opts.isStatic;
  
                  // Grab mixin members
                  for (key in current.$static[$class].methods) {
                      if (!hasOwn(constructor.prototype, key)) {    // Already defined members are not overwritten
                          // We need to clone the metadata and delete the allowed because otherwise multiple classes borrowing from the same would have access
                          // Same applies to the things bellow
                          opts.metadata = mixIn({}, current.$static[$class].methods[key]);
                          delete opts.metadata.allowed;
                          addMethod(key, opts.metadata.implementation || current[key], constructor, opts);
                      }
                  }
  
                  for (key in current.$static[$class].properties) {
                      if (!hasOwn(constructor.prototype, key)) {    // Already defined members are not overwritten
                          opts.metadata = mixIn({}, current.$static[$class].properties[key]);
                          delete opts.metadata.allowed;
                          addProperty(key, opts.metadata.value || current[key], constructor, opts);
                      }
                  }
  
                  opts.isStatic = true;
  
                  // Grab mixin static members
                  for (key in current.$static[$class].staticMethods) {
                      opts.metadata = mixIn({}, current.$static[$class].staticMethods[key]);
                      delete opts.metadata.allowed;
                      addMethod(key, opts.metadata.implementation || current.$static[key], constructor, opts);
                  }
  
                  for (key in current.$static[$class].staticProperties) {
                      opts.metadata = mixIn({}, current.$static[$class].staticProperties[key]);
                      delete opts.metadata.allowed;
                      addProperty(key, opts.metadata.value || current.$static[key], constructor, opts);
                  }
  
                  if (current.$static[$class].isVanilla) {
                      constructor[$class].forceUnlocked = true;
                  }
  
                  // Merge the binds
                  combine(constructor[$class].binds, current.$static[$class].binds);
              }
  
              delete params.$borrows;
          }
      }