code: function xmultiple(...parents) {
      // For now, ensure homogeneous parents
      // That is, objects multi-inherit from objects, and classes multi-inherit from classes
      // In the future, might loosen this restriction, but for now, keeping it simple
      const isEveryParentObject = parents.every(parent => typeof(parent) === 'object');
      const isEveryParentClass = parents.every(parent => typeof(parent) === 'function');
  
      // Forward to more specialized functions depending on argument types
      if (isEveryParentObject) {
          return xmultipleObjects(parents);
      } else if (isEveryParentClass) {
          return xmultipleClasses(parents);
      } else {
          throw new TypeError('Either every parent should be an ordinary object or every parent should be a class.');
      }
  }
docs: Creates a proxy object that delegates property accesses to not just one other
  object (as the prototype chain does) but to multiple other objects.
  
  @param {...Object|...ConstructorFunction} parents An argument list consisting
  entirely of plain objects or entirely of constructor functions.
  @return {Proxy}
  
  @example
  
  const base1 = {'foo': 'foo'};
  const base2 = {'bar': 'bar'};
  const base3 = {'baz': 'baz'};
  
  const delegatesToMultiple = xmultiple(base1, base2, base3);
  delegatesToMultiple.foo // "foo"
  delegatesToMultiple.bar // "bar"
  delegatesToMultiple.baz // "baz"
  
  @example
  
  class Base1 {
  foo() {
  return 'foo';
  }
  }
  
  class Base2 {
  bar() {
  return 'bar';
  }
  }
  
  class Base3 {
  baz() {
  return 'baz';
  }
  }
  
  class DelegatesToMultiple extends xmultiple(Base1, Base2, Base3) {
  }
  
  const delegatesToMultiple = new DelegatesToMultiple();
  delegatesToMultiple.foo() // "foo"
  delegatesToMultiple.bar() // "bar"
  delegatesToMultiple.baz() // "baz"