test.js.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`Dictionary.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const convertURL = require(\\"./URL.js\\").convert;
const convertURLSearchParams = require(\\"./URLSearchParams.js\\").convert;

module.exports = {
  convertInherit(obj, ret, { context = \\"The provided value\\" } = {}) {
    {
      const key = \\"boolWithDefault\\";
      let value = obj === undefined || obj === null ? undefined : obj[key];
      if (value !== undefined) {
        value = conversions[\\"boolean\\"](value, { context: context + \\" has member boolWithDefault that\\" });

        ret[key] = value;
      } else {
        ret[key] = false;
      }
    }

    {
      const key = \\"requiredInterface\\";
      let value = obj === undefined || obj === null ? undefined : obj[key];
      if (value !== undefined) {
        value = convertURL(value, { context: context + \\" has member requiredInterface that\\" });

        ret[key] = value;
      } else {
        throw new TypeError(\\"requiredInterface is required in 'Dictionary'\\");
      }
    }

    {
      const key = \\"seq\\";
      let value = obj === undefined || obj === null ? undefined : obj[key];
      if (value !== undefined) {
        if (!utils.isObject(value)) {
          throw new TypeError(context + \\" has member seq that\\" + \\" is not an iterable object.\\");
        } else {
          const V = [];
          const tmp = value;
          for (let nextItem of tmp) {
            nextItem = convertURLSearchParams(nextItem, { context: context + \\" has member seq that\\" + \\"'s element\\" });

            V.push(nextItem);
          }
          value = V;
        }

        ret[key] = value;
      }
    }

    {
      const key = \\"vanillaString\\";
      let value = obj === undefined || obj === null ? undefined : obj[key];
      if (value !== undefined) {
        value = conversions[\\"DOMString\\"](value, { context: context + \\" has member vanillaString that\\" });

        ret[key] = value;
      }
    }
  },

  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (obj !== undefined && typeof obj !== \\"object\\" && typeof obj !== \\"function\\") {
      throw new TypeError(\`\${context} is not an object.\`);
    }

    const ret = Object.create(null);
    module.exports.convertInherit(obj, ret, { context });
    return ret;
  }
};
"
`;

exports[`Factory.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

module.exports = {
  createInterface: function(defaultPrivateData = {}) {
    function Factory() {
      throw new TypeError(\\"Illegal constructor\\");
    }

    Object.defineProperty(Factory, \\"prototype\\", {
      value: Factory.prototype,
      writable: false,
      enumerable: false,
      configurable: false
    });

    Factory.prototype.method = function method() {
      if (!this || !module.exports.is(this)) {
        throw new TypeError(\\"Illegal invocation\\");
      }

      return this[impl].method();
    };

    Object.defineProperty(Factory.prototype, \\"attribute\\", {
      get() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        return this[impl][\\"attribute\\"];
      },

      set(V) {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        V = conversions[\\"double\\"](V, {
          context: \\"Failed to set the 'attribute' property on 'Factory': The provided value\\"
        });

        this[impl][\\"attribute\\"] = V;
      },

      enumerable: true,
      configurable: true
    });

    Object.defineProperty(Factory, \\"constant\\", {
      value: 42,
      enumerable: true
    });
    Object.defineProperty(Factory.prototype, \\"constant\\", {
      value: 42,
      enumerable: true
    });

    Object.defineProperty(Factory.prototype, Symbol.toStringTag, {
      value: \\"Factory\\",
      writable: false,
      enumerable: false,
      configurable: true
    });

    const iface = {
      create(constructorArgs, privateData) {
        let obj = Object.create(Factory.prototype);
        obj = this.setup(obj, constructorArgs, privateData);
        return obj;
      },
      createImpl(constructorArgs, privateData) {
        let obj = Object.create(Factory.prototype);
        obj = this.setup(obj, constructorArgs, privateData);
        return utils.implForWrapper(obj);
      },
      _internalSetup(obj) {},
      setup(obj, constructorArgs, privateData) {
        if (!privateData) privateData = {};

        for (var prop in defaultPrivateData) {
          if (!(prop in privateData)) {
            privateData[prop] = defaultPrivateData[prop];
          }
        }

        privateData.wrapper = obj;

        this._internalSetup(obj);
        Object.defineProperty(obj, impl, {
          value: new Impl.implementation(constructorArgs, privateData),
          writable: false,
          enumerable: false,
          configurable: true
        });

        obj[impl][utils.wrapperSymbol] = obj;
        if (Impl.init) {
          Impl.init(obj[impl], privateData);
        }
        return obj;
      },
      interface: Factory,
      expose: {
        Window: { Factory }
      }
    }; // iface
    return iface;
  }, // createInterface

  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'Factory'.\`);
  }
}; // module.exports

const Impl = require(\\"../implementations/Factory.js\\");
"
`;

exports[`LegacyArrayClass.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function LegacyArrayClass() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.setPrototypeOf(LegacyArrayClass.prototype, Array.prototype);

Object.defineProperty(LegacyArrayClass, \\"prototype\\", {
  value: LegacyArrayClass.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(LegacyArrayClass.prototype, \\"length\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"length\\"];
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(LegacyArrayClass.prototype, Symbol.toStringTag, {
  value: \\"LegacyArrayClass\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'LegacyArrayClass'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(LegacyArrayClass.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(LegacyArrayClass.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: LegacyArrayClass,
  expose: {
    Window: { LegacyArrayClass }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/LegacyArrayClass.js\\");
"
`;

exports[`PromiseTypes.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function PromiseTypes() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(PromiseTypes, \\"prototype\\", {
  value: PromiseTypes.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

PromiseTypes.prototype.voidPromiseConsumer = function voidPromiseConsumer(p) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'voidPromiseConsumer' on 'PromiseTypes': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = Promise.resolve(args[0]).then(value => {}, reason => reason);

  return this[impl].voidPromiseConsumer(...args);
};

PromiseTypes.prototype.promiseConsumer = function promiseConsumer(p) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'promiseConsumer' on 'PromiseTypes': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = Promise.resolve(args[0]).then(value => {
    value = conversions[\\"double\\"](value, {
      context: \\"Failed to execute 'promiseConsumer' on 'PromiseTypes': parameter 1\\" + \\" promise value\\"
    });

    return value;
  }, reason => reason);

  return this[impl].promiseConsumer(...args);
};

Object.defineProperty(PromiseTypes.prototype, Symbol.toStringTag, {
  value: \\"PromiseTypes\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'PromiseTypes'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(PromiseTypes.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(PromiseTypes.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: PromiseTypes,
  expose: {
    Window: { PromiseTypes }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/PromiseTypes.js\\");
"
`;

exports[`SeqAndRec.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const convertURL = require(\\"./URL.js\\").convert;
const impl = utils.implSymbol;

function SeqAndRec() {
  iface.setup(this);
}

Object.defineProperty(SeqAndRec, \\"prototype\\", {
  value: SeqAndRec.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

SeqAndRec.prototype.recordConsumer = function recordConsumer(rec) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'recordConsumer' on 'SeqAndRec': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(\\"Failed to execute 'recordConsumer' on 'SeqAndRec': parameter 1\\" + \\" is not an object.\\");
  } else {
    const result = Object.create(null);
    for (const key of Reflect.ownKeys(args[0])) {
      const desc = Object.getOwnPropertyDescriptor(args[0], key);
      if (desc && desc.enumerable) {
        let typedKey = key;
        let typedValue = args[0][key];

        typedKey = conversions[\\"USVString\\"](typedKey, {
          context: \\"Failed to execute 'recordConsumer' on 'SeqAndRec': parameter 1\\" + \\"'s key\\"
        });

        typedValue = conversions[\\"double\\"](typedValue, {
          context: \\"Failed to execute 'recordConsumer' on 'SeqAndRec': parameter 1\\" + \\"'s value\\"
        });

        result[typedKey] = typedValue;
      }
    }
    args[0] = result;
  }

  return this[impl].recordConsumer(...args);
};

SeqAndRec.prototype.recordConsumer2 = function recordConsumer2(rec) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'recordConsumer2' on 'SeqAndRec': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(\\"Failed to execute 'recordConsumer2' on 'SeqAndRec': parameter 1\\" + \\" is not an object.\\");
  } else {
    const result = Object.create(null);
    for (const key of Reflect.ownKeys(args[0])) {
      const desc = Object.getOwnPropertyDescriptor(args[0], key);
      if (desc && desc.enumerable) {
        let typedKey = key;
        let typedValue = args[0][key];

        typedKey = conversions[\\"USVString\\"](typedKey, {
          context: \\"Failed to execute 'recordConsumer2' on 'SeqAndRec': parameter 1\\" + \\"'s key\\"
        });

        typedValue = convertURL(typedValue, {
          context: \\"Failed to execute 'recordConsumer2' on 'SeqAndRec': parameter 1\\" + \\"'s value\\"
        });

        result[typedKey] = typedValue;
      }
    }
    args[0] = result;
  }

  return this[impl].recordConsumer2(...args);
};

SeqAndRec.prototype.sequenceConsumer = function sequenceConsumer(seq) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'sequenceConsumer' on 'SeqAndRec': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(
      \\"Failed to execute 'sequenceConsumer' on 'SeqAndRec': parameter 1\\" + \\" is not an iterable object.\\"
    );
  } else {
    const V = [];
    const tmp = args[0];
    for (let nextItem of tmp) {
      nextItem = conversions[\\"USVString\\"](nextItem, {
        context: \\"Failed to execute 'sequenceConsumer' on 'SeqAndRec': parameter 1\\" + \\"'s element\\"
      });

      V.push(nextItem);
    }
    args[0] = V;
  }

  return this[impl].sequenceConsumer(...args);
};

SeqAndRec.prototype.sequenceConsumer2 = function sequenceConsumer2(seq) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'sequenceConsumer2' on 'SeqAndRec': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(
      \\"Failed to execute 'sequenceConsumer2' on 'SeqAndRec': parameter 1\\" + \\" is not an iterable object.\\"
    );
  } else {
    const V = [];
    const tmp = args[0];
    for (let nextItem of tmp) {
      nextItem = utils.tryImplForWrapper(nextItem);

      V.push(nextItem);
    }
    args[0] = V;
  }

  return this[impl].sequenceConsumer2(...args);
};

SeqAndRec.prototype.frozenArrayConsumer = function frozenArrayConsumer(arr) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'frozenArrayConsumer' on 'SeqAndRec': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(
      \\"Failed to execute 'frozenArrayConsumer' on 'SeqAndRec': parameter 1\\" + \\" is not an iterable object.\\"
    );
  } else {
    const V = [];
    const tmp = args[0];
    for (let nextItem of tmp) {
      nextItem = conversions[\\"double\\"](nextItem, {
        context: \\"Failed to execute 'frozenArrayConsumer' on 'SeqAndRec': parameter 1\\" + \\"'s element\\"
      });

      V.push(nextItem);
    }
    args[0] = V;
  }
  args[0] = Object.freeze(args[0]);
  return this[impl].frozenArrayConsumer(...args);
};

Object.defineProperty(SeqAndRec.prototype, Symbol.toStringTag, {
  value: \\"SeqAndRec\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'SeqAndRec'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(SeqAndRec.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(SeqAndRec.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: SeqAndRec,
  expose: {
    Window: { SeqAndRec }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/SeqAndRec.js\\");
"
`;

exports[`Storage.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function Storage() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(Storage, \\"prototype\\", {
  value: Storage.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Storage.prototype.key = function key(index) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'key' on 'Storage': 1 \\" + \\"argument required, but only \\" + arguments.length + \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"unsigned long\\"](args[0], { context: \\"Failed to execute 'key' on 'Storage': parameter 1\\" });

  return this[impl].key(...args);
};

Storage.prototype.getItem = function getItem(key) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'getItem' on 'Storage': 1 \\" + \\"argument required, but only \\" + arguments.length + \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"DOMString\\"](args[0], { context: \\"Failed to execute 'getItem' on 'Storage': parameter 1\\" });

  return this[impl].getItem(...args);
};

Storage.prototype.setItem = function setItem(key, value) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 2) {
    throw new TypeError(
      \\"Failed to execute 'setItem' on 'Storage': 2 \\" + \\"arguments required, but only \\" + arguments.length + \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 2; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"DOMString\\"](args[0], { context: \\"Failed to execute 'setItem' on 'Storage': parameter 1\\" });

  args[1] = conversions[\\"DOMString\\"](args[1], { context: \\"Failed to execute 'setItem' on 'Storage': parameter 2\\" });

  return this[impl].setItem(...args);
};

Storage.prototype.removeItem = function removeItem(key) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'removeItem' on 'Storage': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"DOMString\\"](args[0], { context: \\"Failed to execute 'removeItem' on 'Storage': parameter 1\\" });

  return this[impl].removeItem(...args);
};

Storage.prototype.clear = function clear() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].clear();
};

Object.defineProperty(Storage.prototype, \\"length\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"length\\"];
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(Storage.prototype, Symbol.toStringTag, {
  value: \\"Storage\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'Storage'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(Storage.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(Storage.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj = new Proxy(obj, {
      get(target, P, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.get(target, P, receiver);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc === undefined) {
          const parent = Object.getPrototypeOf(target);
          if (parent === null) {
            return undefined;
          }
          return Reflect.get(target, P, receiver);
        }
        if (!desc.get && !desc.set) {
          return desc.value;
        }
        const getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return Reflect.apply(getter, receiver, []);
      },

      has(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.has(target, P);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc !== undefined) {
          return true;
        }
        const parent = Object.getPrototypeOf(target);
        if (parent !== null) {
          return Reflect.has(parent, P);
        }
        return false;
      },

      ownKeys(target) {
        const keys = new Set();

        for (const key of target[impl][utils.supportedPropertyNames]) {
          if (!(key in target)) {
            keys.add(\`\${key}\`);
          }
        }

        for (const key of Reflect.ownKeys(target)) {
          keys.add(key);
        }
        return [...keys];
      },

      getOwnPropertyDescriptor(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.getOwnPropertyDescriptor(target, P);
        }
        let ignoreNamedProps = false;

        if (target[impl][utils.supportsPropertyName](P) && !(P in target) && !ignoreNamedProps) {
          const namedValue = target[impl].getItem(P);

          return {
            writable: true,
            enumerable: true,
            configurable: true,
            value: utils.tryWrapperForImpl(namedValue)
          };
        }

        return Reflect.getOwnPropertyDescriptor(target, P);
      },

      set(target, P, V, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.set(target, P, V, receiver);
        }
        if (target === receiver) {
          if (typeof P === \\"string\\" && !utils.isArrayIndexPropName(P)) {
            let namedValue = V;

            namedValue = conversions[\\"DOMString\\"](namedValue, {
              context: \\"Failed to set the '\\" + P + \\"' property on 'Storage': The provided value\\"
            });

            target[impl].setItem(P, namedValue);

            return true;
          }
        }
        let ownDesc;

        if (ownDesc === undefined) {
          ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
        }
        if (ownDesc === undefined) {
          const parent = Reflect.getPrototypeOf(target);
          if (parent !== null) {
            return Reflect.set(parent, P, V, receiver);
          }
          ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
        }
        if (!ownDesc.writable) {
          return false;
        }
        if (!utils.isObject(receiver)) {
          return false;
        }
        const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
        let valueDesc;
        if (existingDesc !== undefined) {
          if (existingDesc.get || existingDesc.set) {
            return false;
          }
          if (!existingDesc.writable) {
            return false;
          }
          valueDesc = { value: V };
        } else {
          valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
        }
        return Reflect.defineProperty(receiver, P, valueDesc);
      },

      defineProperty(target, P, desc) {
        if (typeof P === \\"symbol\\") {
          return Reflect.defineProperty(target, P, desc);
        }
        if (!Object.prototype.hasOwnProperty.call(target, P)) {
          if (desc.get || desc.set) {
            return false;
          }

          let namedValue = desc.value;

          namedValue = conversions[\\"DOMString\\"](namedValue, {
            context: \\"Failed to set the '\\" + P + \\"' property on 'Storage': The provided value\\"
          });

          target[impl].setItem(P, namedValue);

          return true;
        }
        return Reflect.defineProperty(target, P, desc);
      },

      deleteProperty(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.deleteProperty(target, P);
        }

        if (target[impl][utils.supportsPropertyName](P) && !(P in target)) {
          target[impl].removeItem(P);
          return true;
        }

        return Reflect.deleteProperty(target, P);
      },

      preventExtensions() {
        return false;
      }
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: Storage,
  expose: {
    Window: { Storage }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/Storage.js\\");
"
`;

exports[`StringifierAttribute.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function StringifierAttribute() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(StringifierAttribute, \\"prototype\\", {
  value: StringifierAttribute.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(StringifierAttribute.prototype, \\"attr\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"attr\\"];
  },

  enumerable: true,
  configurable: true
});

StringifierAttribute.prototype.toString = function toString() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }
  return this[impl][\\"attr\\"];
};

Object.defineProperty(StringifierAttribute.prototype, Symbol.toStringTag, {
  value: \\"StringifierAttribute\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'StringifierAttribute'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(StringifierAttribute.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(StringifierAttribute.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: StringifierAttribute,
  expose: {
    Window: { StringifierAttribute }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/StringifierAttribute.js\\");
"
`;

exports[`StringifierDefaultOperation.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function StringifierDefaultOperation() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(StringifierDefaultOperation, \\"prototype\\", {
  value: StringifierDefaultOperation.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

StringifierDefaultOperation.prototype.toString = function toString() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].toString();
};

Object.defineProperty(StringifierDefaultOperation.prototype, Symbol.toStringTag, {
  value: \\"StringifierDefaultOperation\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'StringifierDefaultOperation'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(StringifierDefaultOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(StringifierDefaultOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: StringifierDefaultOperation,
  expose: {
    Window: { StringifierDefaultOperation }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/StringifierDefaultOperation.js\\");
"
`;

exports[`StringifierNamedOperation.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function StringifierNamedOperation() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(StringifierNamedOperation, \\"prototype\\", {
  value: StringifierNamedOperation.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

StringifierNamedOperation.prototype.operation = function operation() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].operation();
};

Object.defineProperty(StringifierNamedOperation.prototype, Symbol.toStringTag, {
  value: \\"StringifierNamedOperation\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'StringifierNamedOperation'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(StringifierNamedOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(StringifierNamedOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: StringifierNamedOperation,
  expose: {
    Window: { StringifierNamedOperation }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/StringifierNamedOperation.js\\");
"
`;

exports[`StringifierOperation.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function StringifierOperation() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(StringifierOperation, \\"prototype\\", {
  value: StringifierOperation.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

StringifierOperation.prototype.toString = function toString() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].toString();
};

Object.defineProperty(StringifierOperation.prototype, Symbol.toStringTag, {
  value: \\"StringifierOperation\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'StringifierOperation'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(StringifierOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(StringifierOperation.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: StringifierOperation,
  expose: {
    Window: { StringifierOperation }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/StringifierOperation.js\\");
"
`;

exports[`TypedefsAndUnions.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const isURL = require(\\"./URL.js\\").is;
const convertURL = require(\\"./URL.js\\").convert;
const impl = utils.implSymbol;

function TypedefsAndUnions() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(TypedefsAndUnions, \\"prototype\\", {
  value: TypedefsAndUnions.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

TypedefsAndUnions.prototype.numOrStrConsumer = function numOrStrConsumer(a) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'numOrStrConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (typeof args[0] === \\"number\\") {
    args[0] = conversions[\\"double\\"](args[0], {
      context: \\"Failed to execute 'numOrStrConsumer' on 'TypedefsAndUnions': parameter 1\\",
      clamp: true
    });
  } else {
    args[0] = conversions[\\"DOMString\\"](args[0], {
      context: \\"Failed to execute 'numOrStrConsumer' on 'TypedefsAndUnions': parameter 1\\"
    });
  }
  return this[impl].numOrStrConsumer(...args);
};

TypedefsAndUnions.prototype.numOrStrOrNullConsumer = function numOrStrOrNullConsumer(a) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'numOrStrOrNullConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (args[0] === null || args[0] === undefined) {
    args[0] = null;
  } else {
    if (typeof args[0] === \\"number\\") {
      args[0] = conversions[\\"double\\"](args[0], {
        context: \\"Failed to execute 'numOrStrOrNullConsumer' on 'TypedefsAndUnions': parameter 1\\",
        clamp: true,
        enforceRange: true
      });
    } else {
      args[0] = conversions[\\"DOMString\\"](args[0], {
        context: \\"Failed to execute 'numOrStrOrNullConsumer' on 'TypedefsAndUnions': parameter 1\\",
        enforceRange: true
      });
    }
  }
  return this[impl].numOrStrOrNullConsumer(...args);
};

TypedefsAndUnions.prototype.numOrStrOrURLOrNullConsumer = function numOrStrOrURLOrNullConsumer(a) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'numOrStrOrURLOrNullConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (args[0] === null || args[0] === undefined) {
    args[0] = null;
  } else {
    if (isURL(args[0])) {
      args[0] = utils.implForWrapper(args[0]);
    } else if (typeof args[0] === \\"number\\") {
      args[0] = conversions[\\"double\\"](args[0], {
        context: \\"Failed to execute 'numOrStrOrURLOrNullConsumer' on 'TypedefsAndUnions': parameter 1\\",
        clamp: true,
        enforceRange: true
      });
    } else {
      args[0] = conversions[\\"DOMString\\"](args[0], {
        context: \\"Failed to execute 'numOrStrOrURLOrNullConsumer' on 'TypedefsAndUnions': parameter 1\\",
        enforceRange: true
      });
    }
  }
  return this[impl].numOrStrOrURLOrNullConsumer(...args);
};

TypedefsAndUnions.prototype.urlMapInnerConsumer = function urlMapInnerConsumer(a) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'urlMapInnerConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (!utils.isObject(args[0])) {
    throw new TypeError(
      \\"Failed to execute 'urlMapInnerConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\" is not an object.\\"
    );
  } else {
    const result = Object.create(null);
    for (const key of Reflect.ownKeys(args[0])) {
      const desc = Object.getOwnPropertyDescriptor(args[0], key);
      if (desc && desc.enumerable) {
        let typedKey = key;
        let typedValue = args[0][key];

        typedKey = conversions[\\"USVString\\"](typedKey, {
          context: \\"Failed to execute 'urlMapInnerConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\"'s key\\"
        });

        typedValue = convertURL(typedValue, {
          context: \\"Failed to execute 'urlMapInnerConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\"'s value\\"
        });

        result[typedKey] = typedValue;
      }
    }
    args[0] = result;
  }

  return this[impl].urlMapInnerConsumer(...args);
};

TypedefsAndUnions.prototype.urlMapConsumer = function urlMapConsumer(a) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'urlMapConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (args[0] === null || args[0] === undefined) {
    args[0] = null;
  } else {
    if (!utils.isObject(args[0])) {
      throw new TypeError(
        \\"Failed to execute 'urlMapConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\" is not an object.\\"
      );
    } else {
      const result = Object.create(null);
      for (const key of Reflect.ownKeys(args[0])) {
        const desc = Object.getOwnPropertyDescriptor(args[0], key);
        if (desc && desc.enumerable) {
          let typedKey = key;
          let typedValue = args[0][key];

          typedKey = conversions[\\"USVString\\"](typedKey, {
            context: \\"Failed to execute 'urlMapConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\"'s key\\"
          });

          typedValue = convertURL(typedValue, {
            context: \\"Failed to execute 'urlMapConsumer' on 'TypedefsAndUnions': parameter 1\\" + \\"'s value\\"
          });

          result[typedKey] = typedValue;
        }
      }
      args[0] = result;
    }
  }
  return this[impl].urlMapConsumer(...args);
};

TypedefsAndUnions.prototype.bufferSourceOrURLConsumer = function bufferSourceOrURLConsumer(b) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'bufferSourceOrURLConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (isURL(args[0])) {
    args[0] = utils.implForWrapper(args[0]);
  } else if (args[0] instanceof ArrayBuffer) {
  } else if (ArrayBuffer.isView(args[0])) {
  } else {
    throw new TypeError(
      \\"Failed to execute 'bufferSourceOrURLConsumer' on 'TypedefsAndUnions': parameter 1\\" +
        \\" is not of any supported type.\\"
    );
  }
  return this[impl].bufferSourceOrURLConsumer(...args);
};

TypedefsAndUnions.prototype.arrayBufferViewOrURLMapConsumer = function arrayBufferViewOrURLMapConsumer(b) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'arrayBufferViewOrURLMapConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (args[0] === null || args[0] === undefined) {
    args[0] = null;
  } else {
    if (ArrayBuffer.isView(args[0])) {
    } else if (utils.isObject(args[0])) {
      if (!utils.isObject(args[0])) {
        throw new TypeError(
          \\"Failed to execute 'arrayBufferViewOrURLMapConsumer' on 'TypedefsAndUnions': parameter 1\\" +
            \\" record\\" +
            \\" is not an object.\\"
        );
      } else {
        const result = Object.create(null);
        for (const key of Reflect.ownKeys(args[0])) {
          const desc = Object.getOwnPropertyDescriptor(args[0], key);
          if (desc && desc.enumerable) {
            let typedKey = key;
            let typedValue = args[0][key];

            typedKey = conversions[\\"USVString\\"](typedKey, {
              context:
                \\"Failed to execute 'arrayBufferViewOrURLMapConsumer' on 'TypedefsAndUnions': parameter 1\\" +
                \\" record\\" +
                \\"'s key\\"
            });

            typedValue = convertURL(typedValue, {
              context:
                \\"Failed to execute 'arrayBufferViewOrURLMapConsumer' on 'TypedefsAndUnions': parameter 1\\" +
                \\" record\\" +
                \\"'s value\\"
            });

            result[typedKey] = typedValue;
          }
        }
        args[0] = result;
      }
    } else {
      throw new TypeError(
        \\"Failed to execute 'arrayBufferViewOrURLMapConsumer' on 'TypedefsAndUnions': parameter 1\\" +
          \\" is not of any supported type.\\"
      );
    }
  }
  return this[impl].arrayBufferViewOrURLMapConsumer(...args);
};

TypedefsAndUnions.prototype.arrayBufferViewDupConsumer = function arrayBufferViewDupConsumer(b) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'arrayBufferViewDupConsumer' on 'TypedefsAndUnions': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }
  if (ArrayBuffer.isView(args[0])) {
  } else {
    throw new TypeError(
      \\"Failed to execute 'arrayBufferViewDupConsumer' on 'TypedefsAndUnions': parameter 1\\" +
        \\" is not of any supported type.\\"
    );
  }
  return this[impl].arrayBufferViewDupConsumer(...args);
};

Object.defineProperty(TypedefsAndUnions.prototype, \\"buf\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return utils.tryWrapperForImpl(this[impl][\\"buf\\"]);
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    if (V instanceof ArrayBuffer) {
    } else if (ArrayBuffer.isView(V) && (V instanceof Uint8Array || V instanceof Uint16Array)) {
    } else {
      throw new TypeError(
        \\"Failed to set the 'buf' property on 'TypedefsAndUnions': The provided value\\" + \\" is not of any supported type.\\"
      );
    }
    this[impl][\\"buf\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(TypedefsAndUnions.prototype, \\"time\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"time\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"unsigned long long\\"](V, {
      context: \\"Failed to set the 'time' property on 'TypedefsAndUnions': The provided value\\"
    });

    this[impl][\\"time\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(TypedefsAndUnions.prototype, Symbol.toStringTag, {
  value: \\"TypedefsAndUnions\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'TypedefsAndUnions'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(TypedefsAndUnions.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(TypedefsAndUnions.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: TypedefsAndUnions,
  expose: {
    Window: { TypedefsAndUnions }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/TypedefsAndUnions.js\\");
"
`;

exports[`URL.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function URL(url) {
  if (!new.target) {
    throw new TypeError(
      \\"Failed to construct 'URL'. Please use the 'new' operator; this constructor \\" + \\"cannot be called as a function.\\"
    );
  }
  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to construct 'URL': 1 \\" + \\"argument required, but only \\" + arguments.length + \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 2; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], { context: \\"Failed to construct 'URL': parameter 1\\" });

  if (args[1] !== undefined) {
    args[1] = conversions[\\"USVString\\"](args[1], { context: \\"Failed to construct 'URL': parameter 2\\" });
  }

  iface.setup(this, args);
}

Object.defineProperty(URL, \\"prototype\\", {
  value: URL.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

URL.prototype.toJSON = function toJSON() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].toJSON();
};

Object.defineProperty(URL.prototype, \\"href\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"href\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'href' property on 'URL': The provided value\\" });

    this[impl][\\"href\\"] = V;
  },

  enumerable: true,
  configurable: true
});

URL.prototype.toString = function toString() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }
  return this[impl][\\"href\\"];
};

Object.defineProperty(URL.prototype, \\"origin\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"origin\\"];
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"protocol\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"protocol\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'protocol' property on 'URL': The provided value\\" });

    this[impl][\\"protocol\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"username\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"username\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'username' property on 'URL': The provided value\\" });

    this[impl][\\"username\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"password\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"password\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'password' property on 'URL': The provided value\\" });

    this[impl][\\"password\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"host\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"host\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'host' property on 'URL': The provided value\\" });

    this[impl][\\"host\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"hostname\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"hostname\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'hostname' property on 'URL': The provided value\\" });

    this[impl][\\"hostname\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"port\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"port\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'port' property on 'URL': The provided value\\" });

    this[impl][\\"port\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"pathname\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"pathname\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'pathname' property on 'URL': The provided value\\" });

    this[impl][\\"pathname\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"search\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"search\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'search' property on 'URL': The provided value\\" });

    this[impl][\\"search\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"searchParams\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return utils.getSameObject(this, \\"searchParams\\", () => {
      return utils.tryWrapperForImpl(this[impl][\\"searchParams\\"]);
    });
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, \\"hash\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"hash\\"];
  },

  set(V) {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    V = conversions[\\"USVString\\"](V, { context: \\"Failed to set the 'hash' property on 'URL': The provided value\\" });

    this[impl][\\"hash\\"] = V;
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URL.prototype, Symbol.toStringTag, {
  value: \\"URL\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'URL'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(URL.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(URL.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: URL,
  expose: {
    Window: { URL },
    Worker: { URL }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/URL.js\\");
"
`;

exports[`URLList.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function URLList() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(URLList, \\"prototype\\", {
  value: URLList.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(URLList.prototype, Symbol.iterator, {
  writable: true,
  enumerable: false,
  configurable: true,
  value: Array.prototype[Symbol.iterator]
});
URLList.prototype.forEach = Array.prototype.forEach;
URLList.prototype.item = function item(index) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'item' on 'URLList': 1 \\" + \\"argument required, but only \\" + arguments.length + \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"unsigned long\\"](args[0], { context: \\"Failed to execute 'item' on 'URLList': parameter 1\\" });

  return utils.tryWrapperForImpl(this[impl].item(...args));
};

URLList.prototype.entries = Array.prototype.entries;
URLList.prototype.keys = Array.prototype.keys;
URLList.prototype.values = Array.prototype[Symbol.iterator];

Object.defineProperty(URLList.prototype, \\"length\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"length\\"];
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URLList.prototype, Symbol.toStringTag, {
  value: \\"URLList\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'URLList'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(URLList.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(URLList.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj = new Proxy(obj, {
      get(target, P, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.get(target, P, receiver);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc === undefined) {
          const parent = Object.getPrototypeOf(target);
          if (parent === null) {
            return undefined;
          }
          return Reflect.get(target, P, receiver);
        }
        if (!desc.get && !desc.set) {
          return desc.value;
        }
        const getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return Reflect.apply(getter, receiver, []);
      },

      has(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.has(target, P);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc !== undefined) {
          return true;
        }
        const parent = Object.getPrototypeOf(target);
        if (parent !== null) {
          return Reflect.has(parent, P);
        }
        return false;
      },

      ownKeys(target) {
        const keys = new Set();

        for (const key of target[impl][utils.supportedPropertyIndices]) {
          keys.add(\`\${key}\`);
        }

        for (const key of Reflect.ownKeys(target)) {
          keys.add(key);
        }
        return [...keys];
      },

      getOwnPropertyDescriptor(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.getOwnPropertyDescriptor(target, P);
        }
        let ignoreNamedProps = false;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;

          if (target[impl][utils.supportsPropertyIndex](index)) {
            const indexedValue = target[impl].item(index);
            return {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
          ignoreNamedProps = true;
        }

        return Reflect.getOwnPropertyDescriptor(target, P);
      },

      set(target, P, V, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.set(target, P, V, receiver);
        }
        if (target === receiver) {
          utils.isArrayIndexPropName(P);
        }
        let ownDesc;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;

          if (target[impl][utils.supportsPropertyIndex](index)) {
            const indexedValue = target[impl].item(index);
            ownDesc = {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
        }

        if (ownDesc === undefined) {
          ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
        }
        if (ownDesc === undefined) {
          const parent = Reflect.getPrototypeOf(target);
          if (parent !== null) {
            return Reflect.set(parent, P, V, receiver);
          }
          ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
        }
        if (!ownDesc.writable) {
          return false;
        }
        if (!utils.isObject(receiver)) {
          return false;
        }
        const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
        let valueDesc;
        if (existingDesc !== undefined) {
          if (existingDesc.get || existingDesc.set) {
            return false;
          }
          if (!existingDesc.writable) {
            return false;
          }
          valueDesc = { value: V };
        } else {
          valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
        }
        return Reflect.defineProperty(receiver, P, valueDesc);
      },

      defineProperty(target, P, desc) {
        if (typeof P === \\"symbol\\") {
          return Reflect.defineProperty(target, P, desc);
        }

        if (utils.isArrayIndexPropName(P)) {
          return false;
        }

        return Reflect.defineProperty(target, P, desc);
      },

      deleteProperty(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.deleteProperty(target, P);
        }

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          return !target[impl][utils.supportsPropertyIndex](index);
        }

        return Reflect.deleteProperty(target, P);
      },

      preventExtensions() {
        return false;
      }
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: URLList,
  expose: {
    Window: { URLList }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/URLList.js\\");
"
`;

exports[`URLSearchParams.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

const IteratorPrototype = Object.create(utils.IteratorPrototype, {
  next: {
    value: function next() {
      const internal = this[utils.iterInternalSymbol];
      const { target, kind, index } = internal;
      const values = Array.from(target[impl]);
      const len = values.length;
      if (index >= len) {
        return { value: undefined, done: true };
      }

      const pair = values[index];
      internal.index = index + 1;
      const [key, value] = pair.map(utils.tryWrapperForImpl);

      let result;
      switch (kind) {
        case \\"key\\":
          result = key;
          break;
        case \\"value\\":
          result = value;
          break;
        case \\"key+value\\":
          result = [key, value];
          break;
      }
      return { value: result, done: false };
    },
    writable: true,
    enumerable: true,
    configurable: true
  },
  [Symbol.toStringTag]: {
    value: \\"URLSearchParamsIterator\\",
    writable: false,
    enumerable: false,
    configurable: true
  }
});

function URLSearchParams() {
  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  if (args[0] !== undefined) {
    if (utils.isObject(args[0])) {
      if (args[0][Symbol.iterator] !== undefined) {
        if (!utils.isObject(args[0])) {
          throw new TypeError(
            \\"Failed to construct 'URLSearchParams': parameter 1\\" + \\" sequence\\" + \\" is not an iterable object.\\"
          );
        } else {
          const V = [];
          const tmp = args[0];
          for (let nextItem of tmp) {
            if (!utils.isObject(nextItem)) {
              throw new TypeError(
                \\"Failed to construct 'URLSearchParams': parameter 1\\" +
                  \\" sequence\\" +
                  \\"'s element\\" +
                  \\" is not an iterable object.\\"
              );
            } else {
              const V = [];
              const tmp = nextItem;
              for (let nextItem of tmp) {
                nextItem = conversions[\\"USVString\\"](nextItem, {
                  context:
                    \\"Failed to construct 'URLSearchParams': parameter 1\\" + \\" sequence\\" + \\"'s element\\" + \\"'s element\\"
                });

                V.push(nextItem);
              }
              nextItem = V;
            }

            V.push(nextItem);
          }
          args[0] = V;
        }
      } else {
        if (!utils.isObject(args[0])) {
          throw new TypeError(\\"Failed to construct 'URLSearchParams': parameter 1\\" + \\" record\\" + \\" is not an object.\\");
        } else {
          const result = Object.create(null);
          for (const key of Reflect.ownKeys(args[0])) {
            const desc = Object.getOwnPropertyDescriptor(args[0], key);
            if (desc && desc.enumerable) {
              let typedKey = key;
              let typedValue = args[0][key];

              typedKey = conversions[\\"USVString\\"](typedKey, {
                context: \\"Failed to construct 'URLSearchParams': parameter 1\\" + \\" record\\" + \\"'s key\\"
              });

              typedValue = conversions[\\"USVString\\"](typedValue, {
                context: \\"Failed to construct 'URLSearchParams': parameter 1\\" + \\" record\\" + \\"'s value\\"
              });

              result[typedKey] = typedValue;
            }
          }
          args[0] = result;
        }
      }
    } else {
      args[0] = conversions[\\"USVString\\"](args[0], { context: \\"Failed to construct 'URLSearchParams': parameter 1\\" });
    }
  } else {
    args[0] = \\"\\";
  }

  iface.setup(this, args);
}

Object.defineProperty(URLSearchParams, \\"prototype\\", {
  value: URLSearchParams.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(URLSearchParams.prototype, Symbol.iterator, {
  writable: true,
  enumerable: false,
  configurable: true,
  value: function entries() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }
    return module.exports.createDefaultIterator(this, \\"key+value\\");
  }
});
URLSearchParams.prototype.forEach = function forEach(callback) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }
  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'forEach' on 'URLSearchParams': 1 argument required, \\" + \\"but only 0 present.\\"
    );
  }
  if (typeof callback !== \\"function\\") {
    throw new TypeError(
      \\"Failed to execute 'forEach' on 'URLSearchParams': The callback provided \\" + \\"as parameter 1 is not a function.\\"
    );
  }
  const thisArg = arguments[1];
  let pairs = Array.from(this[impl]);
  let i = 0;
  while (i < pairs.length) {
    const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
    callback.call(thisArg, value, key, this);
    pairs = Array.from(this[impl]);
    i++;
  }
};
URLSearchParams.prototype.append = function append(name, value) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 2) {
    throw new TypeError(
      \\"Failed to execute 'append' on 'URLSearchParams': 2 \\" +
        \\"arguments required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 2; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], {
    context: \\"Failed to execute 'append' on 'URLSearchParams': parameter 1\\"
  });

  args[1] = conversions[\\"USVString\\"](args[1], {
    context: \\"Failed to execute 'append' on 'URLSearchParams': parameter 2\\"
  });

  return this[impl].append(...args);
};

URLSearchParams.prototype.delete = function _(name) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'delete' on 'URLSearchParams': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], {
    context: \\"Failed to execute 'delete' on 'URLSearchParams': parameter 1\\"
  });

  return this[impl].delete(...args);
};

URLSearchParams.prototype.get = function get(name) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'get' on 'URLSearchParams': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], { context: \\"Failed to execute 'get' on 'URLSearchParams': parameter 1\\" });

  return this[impl].get(...args);
};

URLSearchParams.prototype.getAll = function getAll(name) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'getAll' on 'URLSearchParams': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], {
    context: \\"Failed to execute 'getAll' on 'URLSearchParams': parameter 1\\"
  });

  return utils.tryWrapperForImpl(this[impl].getAll(...args));
};

URLSearchParams.prototype.has = function has(name) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'has' on 'URLSearchParams': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], { context: \\"Failed to execute 'has' on 'URLSearchParams': parameter 1\\" });

  return this[impl].has(...args);
};

URLSearchParams.prototype.set = function set(name, value) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 2) {
    throw new TypeError(
      \\"Failed to execute 'set' on 'URLSearchParams': 2 \\" +
        \\"arguments required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 2; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"USVString\\"](args[0], { context: \\"Failed to execute 'set' on 'URLSearchParams': parameter 1\\" });

  args[1] = conversions[\\"USVString\\"](args[1], { context: \\"Failed to execute 'set' on 'URLSearchParams': parameter 2\\" });

  return this[impl].set(...args);
};

URLSearchParams.prototype.sort = function sort() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].sort();
};

URLSearchParams.prototype.toString = function toString() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  return this[impl].toString();
};

URLSearchParams.prototype.entries = URLSearchParams.prototype[Symbol.iterator];

URLSearchParams.prototype.keys = function keys() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }
  return module.exports.createDefaultIterator(this, \\"key\\");
};

URLSearchParams.prototype.values = function values() {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }
  return module.exports.createDefaultIterator(this, \\"value\\");
};

Object.defineProperty(URLSearchParams.prototype, Symbol.toStringTag, {
  value: \\"URLSearchParams\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'URLSearchParams'.\`);
  },

  createDefaultIterator(target, kind) {
    const iterator = Object.create(IteratorPrototype);
    Object.defineProperty(iterator, utils.iterInternalSymbol, {
      value: { target, kind, index: 0 },
      writable: false,
      enumerable: false,
      configurable: true
    });
    return iterator;
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParams.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParams.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: URLSearchParams,
  expose: {
    Window: { URLSearchParams },
    Worker: { URLSearchParams }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/URLSearchParams.js\\");
"
`;

exports[`URLSearchParamsCollection.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function URLSearchParamsCollection() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(URLSearchParamsCollection, \\"prototype\\", {
  value: URLSearchParamsCollection.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(URLSearchParamsCollection.prototype, Symbol.iterator, {
  writable: true,
  enumerable: false,
  configurable: true,
  value: Array.prototype[Symbol.iterator]
});

URLSearchParamsCollection.prototype.item = function item(index) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'item' on 'URLSearchParamsCollection': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"unsigned long\\"](args[0], {
    context: \\"Failed to execute 'item' on 'URLSearchParamsCollection': parameter 1\\"
  });

  return utils.tryWrapperForImpl(this[impl].item(...args));
};

URLSearchParamsCollection.prototype.namedItem = function namedItem(name) {
  if (!this || !module.exports.is(this)) {
    throw new TypeError(\\"Illegal invocation\\");
  }

  if (arguments.length < 1) {
    throw new TypeError(
      \\"Failed to execute 'namedItem' on 'URLSearchParamsCollection': 1 \\" +
        \\"argument required, but only \\" +
        arguments.length +
        \\" present.\\"
    );
  }

  const args = [];
  for (let i = 0; i < arguments.length && i < 1; ++i) {
    args[i] = arguments[i];
  }

  args[0] = conversions[\\"DOMString\\"](args[0], {
    context: \\"Failed to execute 'namedItem' on 'URLSearchParamsCollection': parameter 1\\"
  });

  return utils.tryWrapperForImpl(this[impl].namedItem(...args));
};

Object.defineProperty(URLSearchParamsCollection.prototype, \\"length\\", {
  get() {
    if (!this || !module.exports.is(this)) {
      throw new TypeError(\\"Illegal invocation\\");
    }

    return this[impl][\\"length\\"];
  },

  enumerable: true,
  configurable: true
});

Object.defineProperty(URLSearchParamsCollection.prototype, Symbol.toStringTag, {
  value: \\"URLSearchParamsCollection\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'URLSearchParamsCollection'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParamsCollection.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParamsCollection.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj = new Proxy(obj, {
      get(target, P, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.get(target, P, receiver);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc === undefined) {
          const parent = Object.getPrototypeOf(target);
          if (parent === null) {
            return undefined;
          }
          return Reflect.get(target, P, receiver);
        }
        if (!desc.get && !desc.set) {
          return desc.value;
        }
        const getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return Reflect.apply(getter, receiver, []);
      },

      has(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.has(target, P);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc !== undefined) {
          return true;
        }
        const parent = Object.getPrototypeOf(target);
        if (parent !== null) {
          return Reflect.has(parent, P);
        }
        return false;
      },

      ownKeys(target) {
        const keys = new Set();

        for (const key of target[impl][utils.supportedPropertyIndices]) {
          keys.add(\`\${key}\`);
        }

        for (const key of target[impl][utils.supportedPropertyNames]) {
          if (!(key in target)) {
            keys.add(\`\${key}\`);
          }
        }

        for (const key of Reflect.ownKeys(target)) {
          keys.add(key);
        }
        return [...keys];
      },

      getOwnPropertyDescriptor(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.getOwnPropertyDescriptor(target, P);
        }
        let ignoreNamedProps = false;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          const indexedValue = target[impl].item(index);
          if (indexedValue !== undefined) {
            return {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
          ignoreNamedProps = true;
        }

        const namedValue = target[impl].namedItem(P);

        if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
          return {
            writable: false,
            enumerable: false,
            configurable: true,
            value: utils.tryWrapperForImpl(namedValue)
          };
        }

        return Reflect.getOwnPropertyDescriptor(target, P);
      },

      set(target, P, V, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.set(target, P, V, receiver);
        }
        if (target === receiver) {
          utils.isArrayIndexPropName(P);

          typeof P === \\"string\\" && !utils.isArrayIndexPropName(P);
        }
        let ownDesc;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          const indexedValue = target[impl].item(index);
          if (indexedValue !== undefined) {
            ownDesc = {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
        }

        if (ownDesc === undefined) {
          ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
        }
        if (ownDesc === undefined) {
          const parent = Reflect.getPrototypeOf(target);
          if (parent !== null) {
            return Reflect.set(parent, P, V, receiver);
          }
          ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
        }
        if (!ownDesc.writable) {
          return false;
        }
        if (!utils.isObject(receiver)) {
          return false;
        }
        const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
        let valueDesc;
        if (existingDesc !== undefined) {
          if (existingDesc.get || existingDesc.set) {
            return false;
          }
          if (!existingDesc.writable) {
            return false;
          }
          valueDesc = { value: V };
        } else {
          valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
        }
        return Reflect.defineProperty(receiver, P, valueDesc);
      },

      defineProperty(target, P, desc) {
        if (typeof P === \\"symbol\\") {
          return Reflect.defineProperty(target, P, desc);
        }

        if (utils.isArrayIndexPropName(P)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(target, P)) {
          const creating = !(target[impl].namedItem(P) !== null);
          if (!creating) {
            return false;
          }
        }
        return Reflect.defineProperty(target, P, desc);
      },

      deleteProperty(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.deleteProperty(target, P);
        }

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          return !(target[impl].item(index) !== undefined);
        }

        if (target[impl].namedItem(P) !== null && !(P in target)) {
          return false;
        }

        return Reflect.deleteProperty(target, P);
      },

      preventExtensions() {
        return false;
      }
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: URLSearchParamsCollection,
  expose: {
    Window: { URLSearchParamsCollection }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/URLSearchParamsCollection.js\\");
"
`;

exports[`URLSearchParamsCollection2.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const convertURL = require(\\"./URL.js\\").convert;
const impl = utils.implSymbol;
const URLSearchParamsCollection = require(\\"./URLSearchParamsCollection.js\\");

function URLSearchParamsCollection2() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.setPrototypeOf(URLSearchParamsCollection2.prototype, URLSearchParamsCollection.interface.prototype);
Object.setPrototypeOf(URLSearchParamsCollection2, URLSearchParamsCollection.interface);

Object.defineProperty(URLSearchParamsCollection2, \\"prototype\\", {
  value: URLSearchParamsCollection2.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(URLSearchParamsCollection2.prototype, Symbol.iterator, {
  writable: true,
  enumerable: false,
  configurable: true,
  value: Array.prototype[Symbol.iterator]
});

Object.defineProperty(URLSearchParamsCollection2.prototype, Symbol.toStringTag, {
  value: \\"URLSearchParamsCollection2\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'URLSearchParamsCollection2'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParamsCollection2.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(URLSearchParamsCollection2.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {
    URLSearchParamsCollection._internalSetup(obj);
  },
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj = new Proxy(obj, {
      get(target, P, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.get(target, P, receiver);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc === undefined) {
          const parent = Object.getPrototypeOf(target);
          if (parent === null) {
            return undefined;
          }
          return Reflect.get(target, P, receiver);
        }
        if (!desc.get && !desc.set) {
          return desc.value;
        }
        const getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return Reflect.apply(getter, receiver, []);
      },

      has(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.has(target, P);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc !== undefined) {
          return true;
        }
        const parent = Object.getPrototypeOf(target);
        if (parent !== null) {
          return Reflect.has(parent, P);
        }
        return false;
      },

      ownKeys(target) {
        const keys = new Set();

        for (const key of target[impl][utils.supportedPropertyIndices]) {
          keys.add(\`\${key}\`);
        }

        for (const key of target[impl][utils.supportedPropertyNames]) {
          if (!(key in target)) {
            keys.add(\`\${key}\`);
          }
        }

        for (const key of Reflect.ownKeys(target)) {
          keys.add(key);
        }
        return [...keys];
      },

      getOwnPropertyDescriptor(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.getOwnPropertyDescriptor(target, P);
        }
        let ignoreNamedProps = false;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          const indexedValue = target[impl].item(index);
          if (indexedValue !== undefined) {
            return {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
          ignoreNamedProps = true;
        }

        const namedValue = target[impl].namedItem(P);

        if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
          return {
            writable: true,
            enumerable: true,
            configurable: true,
            value: utils.tryWrapperForImpl(namedValue)
          };
        }

        return Reflect.getOwnPropertyDescriptor(target, P);
      },

      set(target, P, V, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.set(target, P, V, receiver);
        }
        if (target === receiver) {
          utils.isArrayIndexPropName(P);

          if (typeof P === \\"string\\" && !utils.isArrayIndexPropName(P)) {
            let namedValue = V;

            namedValue = convertURL(namedValue, {
              context: \\"Failed to set the '\\" + P + \\"' property on 'URLSearchParamsCollection2': The provided value\\"
            });

            const creating = !(target[impl].namedItem(P) !== null);
            if (creating) {
              target[impl][utils.namedSetNew](P, namedValue);
            } else {
              target[impl][utils.namedSetExisting](P, namedValue);
            }

            return true;
          }
        }
        let ownDesc;

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          const indexedValue = target[impl].item(index);
          if (indexedValue !== undefined) {
            ownDesc = {
              writable: false,
              enumerable: true,
              configurable: true,
              value: utils.tryWrapperForImpl(indexedValue)
            };
          }
        }

        if (ownDesc === undefined) {
          ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
        }
        if (ownDesc === undefined) {
          const parent = Reflect.getPrototypeOf(target);
          if (parent !== null) {
            return Reflect.set(parent, P, V, receiver);
          }
          ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
        }
        if (!ownDesc.writable) {
          return false;
        }
        if (!utils.isObject(receiver)) {
          return false;
        }
        const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
        let valueDesc;
        if (existingDesc !== undefined) {
          if (existingDesc.get || existingDesc.set) {
            return false;
          }
          if (!existingDesc.writable) {
            return false;
          }
          valueDesc = { value: V };
        } else {
          valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
        }
        return Reflect.defineProperty(receiver, P, valueDesc);
      },

      defineProperty(target, P, desc) {
        if (typeof P === \\"symbol\\") {
          return Reflect.defineProperty(target, P, desc);
        }

        if (utils.isArrayIndexPropName(P)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(target, P)) {
          if (desc.get || desc.set) {
            return false;
          }

          let namedValue = desc.value;

          namedValue = convertURL(namedValue, {
            context: \\"Failed to set the '\\" + P + \\"' property on 'URLSearchParamsCollection2': The provided value\\"
          });

          const creating = !(target[impl].namedItem(P) !== null);
          if (creating) {
            target[impl][utils.namedSetNew](P, namedValue);
          } else {
            target[impl][utils.namedSetExisting](P, namedValue);
          }

          return true;
        }
        return Reflect.defineProperty(target, P, desc);
      },

      deleteProperty(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.deleteProperty(target, P);
        }

        if (utils.isArrayIndexPropName(P)) {
          const index = P >>> 0;
          return !(target[impl].item(index) !== undefined);
        }

        if (target[impl].namedItem(P) !== null && !(P in target)) {
          return false;
        }

        return Reflect.deleteProperty(target, P);
      },

      preventExtensions() {
        return false;
      }
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: URLSearchParamsCollection2,
  expose: {
    Window: { URLSearchParamsCollection2 }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/URLSearchParamsCollection2.js\\");
"
`;

exports[`Unforgeable.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function Unforgeable() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(Unforgeable, \\"prototype\\", {
  value: Unforgeable.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(Unforgeable.prototype, Symbol.toStringTag, {
  value: \\"Unforgeable\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'Unforgeable'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(Unforgeable.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(Unforgeable.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {
    obj.assign = function assign(url) {
      if (!this || !module.exports.is(this)) {
        throw new TypeError(\\"Illegal invocation\\");
      }

      if (arguments.length < 1) {
        throw new TypeError(
          \\"Failed to execute 'assign' on 'Unforgeable': 1 \\" +
            \\"argument required, but only \\" +
            arguments.length +
            \\" present.\\"
        );
      }

      const args = [];
      for (let i = 0; i < arguments.length && i < 1; ++i) {
        args[i] = arguments[i];
      }

      args[0] = conversions[\\"USVString\\"](args[0], {
        context: \\"Failed to execute 'assign' on 'Unforgeable': parameter 1\\"
      });

      return this[impl].assign(...args);
    };

    Object.defineProperty(obj, \\"href\\", {
      get() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        return obj[impl][\\"href\\"];
      },

      set(V) {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        V = conversions[\\"USVString\\"](V, {
          context: \\"Failed to set the 'href' property on 'Unforgeable': The provided value\\"
        });

        obj[impl][\\"href\\"] = V;
      },

      enumerable: true,
      configurable: false
    });

    Object.defineProperty(obj, \\"toString\\", {
      writable: false,
      enumerable: true,
      configurable: false,
      value: function toString() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }
        return obj[impl][\\"href\\"];
      }
    });

    Object.defineProperty(obj, \\"origin\\", {
      get() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        return obj[impl][\\"origin\\"];
      },

      enumerable: true,
      configurable: false
    });

    Object.defineProperty(obj, \\"protocol\\", {
      get() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        return obj[impl][\\"protocol\\"];
      },

      set(V) {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        V = conversions[\\"USVString\\"](V, {
          context: \\"Failed to set the 'protocol' property on 'Unforgeable': The provided value\\"
        });

        obj[impl][\\"protocol\\"] = V;
      },

      enumerable: true,
      configurable: false
    });
  },
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: Unforgeable,
  expose: {
    Window: { Unforgeable }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/Unforgeable.js\\");
"
`;

exports[`UnforgeableMap.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function UnforgeableMap() {
  throw new TypeError(\\"Illegal constructor\\");
}

Object.defineProperty(UnforgeableMap, \\"prototype\\", {
  value: UnforgeableMap.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(UnforgeableMap.prototype, Symbol.toStringTag, {
  value: \\"UnforgeableMap\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'UnforgeableMap'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(UnforgeableMap.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(UnforgeableMap.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {
    Object.defineProperty(obj, \\"a\\", {
      get() {
        if (!this || !module.exports.is(this)) {
          throw new TypeError(\\"Illegal invocation\\");
        }

        return obj[impl][\\"a\\"];
      },

      enumerable: true,
      configurable: false
    });
  },
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj = new Proxy(obj, {
      get(target, P, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.get(target, P, receiver);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc === undefined) {
          const parent = Object.getPrototypeOf(target);
          if (parent === null) {
            return undefined;
          }
          return Reflect.get(target, P, receiver);
        }
        if (!desc.get && !desc.set) {
          return desc.value;
        }
        const getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return Reflect.apply(getter, receiver, []);
      },

      has(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.has(target, P);
        }
        const desc = this.getOwnPropertyDescriptor(target, P);
        if (desc !== undefined) {
          return true;
        }
        const parent = Object.getPrototypeOf(target);
        if (parent !== null) {
          return Reflect.has(parent, P);
        }
        return false;
      },

      ownKeys(target) {
        const keys = new Set();

        for (const key of target[impl][utils.supportedPropertyNames]) {
          if (!(key in target)) {
            keys.add(\`\${key}\`);
          }
        }

        for (const key of Reflect.ownKeys(target)) {
          keys.add(key);
        }
        return [...keys];
      },

      getOwnPropertyDescriptor(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.getOwnPropertyDescriptor(target, P);
        }
        let ignoreNamedProps = false;

        if (target[impl][utils.supportsPropertyName](P) && !(P in target) && !ignoreNamedProps) {
          const namedValue = target[impl][utils.namedGet](P);

          return {
            writable: true,
            enumerable: true,
            configurable: true,
            value: utils.tryWrapperForImpl(namedValue)
          };
        }

        return Reflect.getOwnPropertyDescriptor(target, P);
      },

      set(target, P, V, receiver) {
        if (typeof P === \\"symbol\\") {
          return Reflect.set(target, P, V, receiver);
        }
        if (target === receiver) {
          if (typeof P === \\"string\\" && !utils.isArrayIndexPropName(P)) {
            let namedValue = V;

            namedValue = conversions[\\"DOMString\\"](namedValue, {
              context: \\"Failed to set the '\\" + P + \\"' property on 'UnforgeableMap': The provided value\\"
            });

            const creating = !target[impl][utils.supportsPropertyName](P);
            if (creating) {
              target[impl][utils.namedSetNew](P, namedValue);
            } else {
              target[impl][utils.namedSetExisting](P, namedValue);
            }

            return true;
          }
        }
        let ownDesc;

        if (ownDesc === undefined) {
          ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
        }
        if (ownDesc === undefined) {
          const parent = Reflect.getPrototypeOf(target);
          if (parent !== null) {
            return Reflect.set(parent, P, V, receiver);
          }
          ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
        }
        if (!ownDesc.writable) {
          return false;
        }
        if (!utils.isObject(receiver)) {
          return false;
        }
        const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
        let valueDesc;
        if (existingDesc !== undefined) {
          if (existingDesc.get || existingDesc.set) {
            return false;
          }
          if (!existingDesc.writable) {
            return false;
          }
          valueDesc = { value: V };
        } else {
          valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
        }
        return Reflect.defineProperty(receiver, P, valueDesc);
      },

      defineProperty(target, P, desc) {
        if (typeof P === \\"symbol\\") {
          return Reflect.defineProperty(target, P, desc);
        }
        if (![\\"a\\"].includes(P)) {
          if (!Object.prototype.hasOwnProperty.call(target, P)) {
            if (desc.get || desc.set) {
              return false;
            }

            let namedValue = desc.value;

            namedValue = conversions[\\"DOMString\\"](namedValue, {
              context: \\"Failed to set the '\\" + P + \\"' property on 'UnforgeableMap': The provided value\\"
            });

            const creating = !target[impl][utils.supportsPropertyName](P);
            if (creating) {
              target[impl][utils.namedSetNew](P, namedValue);
            } else {
              target[impl][utils.namedSetExisting](P, namedValue);
            }

            return true;
          }
        }
        return Reflect.defineProperty(target, P, desc);
      },

      deleteProperty(target, P) {
        if (typeof P === \\"symbol\\") {
          return Reflect.deleteProperty(target, P);
        }

        if (target[impl][utils.supportsPropertyName](P) && !(P in target)) {
          return false;
        }

        return Reflect.deleteProperty(target, P);
      },

      preventExtensions() {
        return false;
      }
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: UnforgeableMap,
  expose: {
    Window: { UnforgeableMap }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/UnforgeableMap.js\\");
"
`;

exports[`ZeroArgConstructor.idl 1`] = `
"\\"use strict\\";

const conversions = require(\\"webidl-conversions\\");
const utils = require(\\"./utils.js\\");

const impl = utils.implSymbol;

function ZeroArgConstructor() {
  iface.setup(this);
}

Object.defineProperty(ZeroArgConstructor, \\"prototype\\", {
  value: ZeroArgConstructor.prototype,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(ZeroArgConstructor.prototype, Symbol.toStringTag, {
  value: \\"ZeroArgConstructor\\",
  writable: false,
  enumerable: false,
  configurable: true
});

const iface = {
  mixedInto: [],
  is(obj) {
    if (obj) {
      if (obj[impl] instanceof Impl.implementation) {
        return true;
      }
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (obj instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  isImpl(obj) {
    if (obj) {
      if (obj instanceof Impl.implementation) {
        return true;
      }

      const wrapper = utils.wrapperForImpl(obj);
      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
        if (wrapper instanceof module.exports.mixedInto[i]) {
          return true;
        }
      }
    }
    return false;
  },
  convert(obj, { context = \\"The provided value\\" } = {}) {
    if (module.exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(\`\${context} is not of type 'ZeroArgConstructor'.\`);
  },

  create(constructorArgs, privateData) {
    let obj = Object.create(ZeroArgConstructor.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return obj;
  },
  createImpl(constructorArgs, privateData) {
    let obj = Object.create(ZeroArgConstructor.prototype);
    obj = this.setup(obj, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  },
  _internalSetup(obj) {},
  setup(obj, constructorArgs, privateData) {
    if (!privateData) privateData = {};

    privateData.wrapper = obj;

    this._internalSetup(obj);
    Object.defineProperty(obj, impl, {
      value: new Impl.implementation(constructorArgs, privateData),
      writable: false,
      enumerable: false,
      configurable: true
    });

    obj[impl][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[impl], privateData);
    }
    return obj;
  },
  interface: ZeroArgConstructor,
  expose: {
    Window: { ZeroArgConstructor }
  }
}; // iface
module.exports = iface;

const Impl = require(\\"../implementations/ZeroArgConstructor.js\\");
"
`;