text: "use strict";
  
  const conversions = require("webidl-conversions");
  const utils = require("./utils.js");
  
  const implSymbol = utils.implSymbol;
  const ctorRegistrySymbol = utils.ctorRegistrySymbol;
  
  const interfaceName = "ValidityState";
  
  exports.is = function is(obj) {
    return utils.isObject(obj) && utils.hasOwn(obj, implSymbol) && obj[implSymbol] instanceof Impl.implementation;
  };
  exports.isImpl = function isImpl(obj) {
    return utils.isObject(obj) && obj instanceof Impl.implementation;
  };
  exports.convert = function convert(obj, { context = "The provided value" } = {}) {
    if (exports.is(obj)) {
      return utils.implForWrapper(obj);
    }
    throw new TypeError(`${context} is not of type 'ValidityState'.`);
  };
  
  exports.create = function create(globalObject, constructorArgs, privateData) {
    if (globalObject[ctorRegistrySymbol] === undefined) {
      throw new Error("Internal error: invalid global object");
    }
  
    const ctor = globalObject[ctorRegistrySymbol]["ValidityState"];
    if (ctor === undefined) {
      throw new Error("Internal error: constructor ValidityState is not installed on the passed global object");
    }
  
    let obj = Object.create(ctor.prototype);
    obj = exports.setup(obj, globalObject, constructorArgs, privateData);
    return obj;
  };
  exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
    const obj = exports.create(globalObject, constructorArgs, privateData);
    return utils.implForWrapper(obj);
  };
  exports._internalSetup = function _internalSetup(obj, globalObject) {};
  exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
    privateData.wrapper = obj;
  
    exports._internalSetup(obj, globalObject);
    Object.defineProperty(obj, implSymbol, {
      value: new Impl.implementation(globalObject, constructorArgs, privateData),
      configurable: true
    });
  
    obj[implSymbol][utils.wrapperSymbol] = obj;
    if (Impl.init) {
      Impl.init(obj[implSymbol], privateData);
    }
    return obj;
  };
  
  exports.install = function install(globalObject) {
    class ValidityState {
      constructor() {
        throw new TypeError("Illegal constructor");
      }
  
      get valueMissing() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["valueMissing"];
      }
  
      get typeMismatch() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["typeMismatch"];
      }
  
      get patternMismatch() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["patternMismatch"];
      }
  
      get tooLong() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["tooLong"];
      }
  
      get tooShort() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["tooShort"];
      }
  
      get rangeUnderflow() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["rangeUnderflow"];
      }
  
      get rangeOverflow() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["rangeOverflow"];
      }
  
      get stepMismatch() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["stepMismatch"];
      }
  
      get badInput() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["badInput"];
      }
  
      get customError() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["customError"];
      }
  
      get valid() {
        const esValue = this !== null && this !== undefined ? this : globalObject;
  
        if (!exports.is(esValue)) {
          throw new TypeError("Illegal invocation");
        }
  
        return esValue[implSymbol]["valid"];
      }
    }
    Object.defineProperties(ValidityState.prototype, {
      valueMissing: { enumerable: true },
      typeMismatch: { enumerable: true },
      patternMismatch: { enumerable: true },
      tooLong: { enumerable: true },
      tooShort: { enumerable: true },
      rangeUnderflow: { enumerable: true },
      rangeOverflow: { enumerable: true },
      stepMismatch: { enumerable: true },
      badInput: { enumerable: true },
      customError: { enumerable: true },
      valid: { enumerable: true },
      [Symbol.toStringTag]: { value: "ValidityState", configurable: true }
    });
    if (globalObject[ctorRegistrySymbol] === undefined) {
      globalObject[ctorRegistrySymbol] = Object.create(null);
    }
    globalObject[ctorRegistrySymbol][interfaceName] = ValidityState;
  
    Object.defineProperty(globalObject, interfaceName, {
      configurable: true,
      writable: true,
      value: ValidityState
    });
  };
  
  const Impl = require("../constraint-validation/ValidityState-impl.js");
  