File Explorer

/proc/self/root/var/runtime/node_modules/@aws-sdk/node_modules/undici/lib/web/webidl

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

index.js29.0 KB · 1007 lines
'use strict' const assert = require('node:assert')const { types, inspect } = require('node:util')const { runtimeFeatures } = require('../../util/runtime-features') const UNDEFINED = 1const BOOLEAN = 2const STRING = 3const SYMBOL = 4const NUMBER = 5const BIGINT = 6const NULL = 7const OBJECT = 8 // function and object const FunctionPrototypeSymbolHasInstance = Function.call.bind(Function.prototype[Symbol.hasInstance]) /** @type {import('../../../types/webidl').Webidl} */const webidl = {  converters: {},  util: {},  errors: {},  is: {}} /** * @description Instantiate an error. * * @param {Object} opts * @param {string} opts.header * @param {string} opts.message * @returns {TypeError} */webidl.errors.exception = function (message) {  return new TypeError(`${message.header}: ${message.message}`)} /** * @description Instantiate an error when conversion from one type to another has failed. * * @param {Object} opts * @param {string} opts.prefix * @param {string} opts.argument * @param {string[]} opts.types * @returns {TypeError} */webidl.errors.conversionFailed = function (opts) {  const plural = opts.types.length === 1 ? '' : ' one of'  const message =    `${opts.argument} could not be converted to` +    `${plural}: ${opts.types.join(', ')}.`   return webidl.errors.exception({    header: opts.prefix,    message  })} /** * @description Instantiate an error when an invalid argument is provided * * @param {Object} context * @param {string} context.prefix * @param {string} context.value * @param {string} context.type * @returns {TypeError} */webidl.errors.invalidArgument = function (context) {  return webidl.errors.exception({    header: context.prefix,    message: `"${context.value}" is an invalid ${context.type}.`  })} // https://webidl.spec.whatwg.org/#implementswebidl.brandCheck = function (V, I) {  if (!FunctionPrototypeSymbolHasInstance(I, V)) {    const err = new TypeError('Illegal invocation')    err.code = 'ERR_INVALID_THIS' // node compat.    throw err  }} webidl.brandCheckMultiple = function (List) {  const prototypes = List.map((c) => webidl.util.MakeTypeAssertion(c))   return (V) => {    if (prototypes.every(typeCheck => !typeCheck(V))) {      const err = new TypeError('Illegal invocation')      err.code = 'ERR_INVALID_THIS' // node compat.      throw err    }  }} webidl.argumentLengthCheck = function ({ length }, min, ctx) {  if (length < min) {    throw webidl.errors.exception({      message: `${min} argument${min !== 1 ? 's' : ''} required, ` +               `but${length ? ' only' : ''} ${length} found.`,      header: ctx    })  }} webidl.illegalConstructor = function () {  throw webidl.errors.exception({    header: 'TypeError',    message: 'Illegal constructor'  })} webidl.util.MakeTypeAssertion = function (I) {  return (O) => FunctionPrototypeSymbolHasInstance(I, O)} // https://tc39.es/ecma262/#sec-ecmascript-data-types-and-valueswebidl.util.Type = function (V) {  switch (typeof V) {    case 'undefined': return UNDEFINED    case 'boolean': return BOOLEAN    case 'string': return STRING    case 'symbol': return SYMBOL    case 'number': return NUMBER    case 'bigint': return BIGINT    case 'function':    case 'object': {      if (V === null) {        return NULL      }       return OBJECT    }  }} webidl.util.Types = {  UNDEFINED,  BOOLEAN,  STRING,  SYMBOL,  NUMBER,  BIGINT,  NULL,  OBJECT} webidl.util.TypeValueToString = function (o) {  switch (webidl.util.Type(o)) {    case UNDEFINED: return 'Undefined'    case BOOLEAN: return 'Boolean'    case STRING: return 'String'    case SYMBOL: return 'Symbol'    case NUMBER: return 'Number'    case BIGINT: return 'BigInt'    case NULL: return 'Null'    case OBJECT: return 'Object'  }} webidl.util.markAsUncloneable = runtimeFeatures.has('markAsUncloneable')  ? require('node:worker_threads').markAsUncloneable  : () => {} // https://webidl.spec.whatwg.org/#abstract-opdef-converttointwebidl.util.ConvertToInt = function (V, bitLength, signedness, flags) {  let upperBound  let lowerBound   // 1. If bitLength is 64, then:  if (bitLength === 64) {    // 1. Let upperBound be 2^53 − 1.    upperBound = Math.pow(2, 53) - 1     // 2. If signedness is "unsigned", then let lowerBound be 0.    if (signedness === 'unsigned') {      lowerBound = 0    } else {      // 3. Otherwise let lowerBound be −2^53 + 1.      lowerBound = Math.pow(-2, 53) + 1    }  } else if (signedness === 'unsigned') {    // 2. Otherwise, if signedness is "unsigned", then:     // 1. Let lowerBound be 0.    lowerBound = 0     // 2. Let upperBound be 2^bitLength − 1.    upperBound = Math.pow(2, bitLength) - 1  } else {    // 3. Otherwise:     // 1. Let lowerBound be -2^(bitLength − 1).    lowerBound = -Math.pow(2, bitLength - 1)     // 2. Let upperBound be 2^(bitLength − 1) − 1.    upperBound = Math.pow(2, bitLength - 1) - 1  }   // 4. Let x be ? ToNumber(V).  let x = Number(V)   // 5. If x is −0, then set x to +0.  if (x === 0) {    x = 0  }   // 6. If the conversion is to an IDL type associated  //    with the [EnforceRange] extended attribute, then:  if (webidl.util.HasFlag(flags, webidl.attributes.EnforceRange)) {    // 1. If x is NaN, +∞, or −∞, then throw a TypeError.    if (      Number.isNaN(x) ||      x === Number.POSITIVE_INFINITY ||      x === Number.NEGATIVE_INFINITY    ) {      throw webidl.errors.exception({        header: 'Integer conversion',        message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`      })    }     // 2. Set x to IntegerPart(x).    x = webidl.util.IntegerPart(x)     // 3. If x < lowerBound or x > upperBound, then    //    throw a TypeError.    if (x < lowerBound || x > upperBound) {      throw webidl.errors.exception({        header: 'Integer conversion',        message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`      })    }     // 4. Return x.    return x  }   // 7. If x is not NaN and the conversion is to an IDL  //    type associated with the [Clamp] extended  //    attribute, then:  if (!Number.isNaN(x) && webidl.util.HasFlag(flags, webidl.attributes.Clamp)) {    // 1. Set x to min(max(x, lowerBound), upperBound).    x = Math.min(Math.max(x, lowerBound), upperBound)     // 2. Round x to the nearest integer, choosing the    //    even integer if it lies halfway between two,    //    and choosing +0 rather than −0.    if (Math.floor(x) % 2 === 0) {      x = Math.floor(x)    } else {      x = Math.ceil(x)    }     // 3. Return x.    return x  }   // 8. If x is NaN, +0, +∞, or −∞, then return +0.  if (    Number.isNaN(x) ||    (x === 0 && Object.is(0, x)) ||    x === Number.POSITIVE_INFINITY ||    x === Number.NEGATIVE_INFINITY  ) {    return 0  }   // 9. Set x to IntegerPart(x).  x = webidl.util.IntegerPart(x)   // 10. Set x to x modulo 2^bitLength.  x = x % Math.pow(2, bitLength)   // 11. If signedness is "signed" and x ≥ 2^(bitLength − 1),  //    then return x − 2^bitLength.  if (signedness === 'signed' && x >= Math.pow(2, bitLength - 1)) {    return x - Math.pow(2, bitLength)  }   // 12. Otherwise, return x.  return x} // https://webidl.spec.whatwg.org/#abstract-opdef-integerpartwebidl.util.IntegerPart = function (n) {  // 1. Let r be floor(abs(n)).  const r = Math.floor(Math.abs(n))   // 2. If n < 0, then return -1 × r.  if (n < 0) {    return -1 * r  }   // 3. Otherwise, return r.  return r} webidl.util.Stringify = function (V) {  const type = webidl.util.Type(V)   switch (type) {    case SYMBOL:      return `Symbol(${V.description})`    case OBJECT:      return inspect(V)    case STRING:      return `"${V}"`    case BIGINT:      return `${V}n`    default:      return `${V}`  }} webidl.util.IsResizableArrayBuffer = function (V) {  if (types.isArrayBuffer(V)) {    return V.resizable  }   if (types.isSharedArrayBuffer(V)) {    return V.growable  }   throw webidl.errors.exception({    header: 'IsResizableArrayBuffer',    message: `"${webidl.util.Stringify(V)}" is not an array buffer.`  })} webidl.util.HasFlag = function (flags, attributes) {  return typeof flags === 'number' && (flags & attributes) === attributes} // https://webidl.spec.whatwg.org/#es-sequencewebidl.sequenceConverter = function (converter) {  return (V, prefix, argument, Iterable) => {    // 1. If Type(V) is not Object, throw a TypeError.    if (webidl.util.Type(V) !== OBJECT) {      throw webidl.errors.exception({        header: prefix,        message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`      })    }     // 2. Let method be ? GetMethod(V, @@iterator).    /** @type {Generator} */    const method = typeof Iterable === 'function' ? Iterable() : V?.[Symbol.iterator]?.()    const seq = []    let index = 0     // 3. If method is undefined, throw a TypeError.    if (      method === undefined ||      typeof method.next !== 'function'    ) {      throw webidl.errors.exception({        header: prefix,        message: `${argument} is not iterable.`      })    }     // https://webidl.spec.whatwg.org/#create-sequence-from-iterable    while (true) {      const { done, value } = method.next()       if (done) {        break      }       seq.push(converter(value, prefix, `${argument}[${index++}]`))    }     return seq  }} // https://webidl.spec.whatwg.org/#es-to-recordwebidl.recordConverter = function (keyConverter, valueConverter) {  return (O, prefix, argument) => {    // 1. If Type(O) is not Object, throw a TypeError.    if (webidl.util.Type(O) !== OBJECT) {      throw webidl.errors.exception({        header: prefix,        message: `${argument} ("${webidl.util.TypeValueToString(O)}") is not an Object.`      })    }     // 2. Let result be a new empty instance of record<K, V>.    const result = {}     if (!types.isProxy(O)) {      // 1. Let desc be ? O.[[GetOwnProperty]](key).      const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]       for (const key of keys) {        const keyName = webidl.util.Stringify(key)         // 1. Let typedKey be key converted to an IDL value of type K.        const typedKey = keyConverter(key, prefix, `Key ${keyName} in ${argument}`)         // 2. Let value be ? Get(O, key).        // 3. Let typedValue be value converted to an IDL value of type V.        const typedValue = valueConverter(O[key], prefix, `${argument}[${keyName}]`)         // 4. Set result[typedKey] to typedValue.        result[typedKey] = typedValue      }       // 5. Return result.      return result    }     // 3. Let keys be ? O.[[OwnPropertyKeys]]().    const keys = Reflect.ownKeys(O)     // 4. For each key of keys.    for (const key of keys) {      // 1. Let desc be ? O.[[GetOwnProperty]](key).      const desc = Reflect.getOwnPropertyDescriptor(O, key)       // 2. If desc is not undefined and desc.[[Enumerable]] is true:      if (desc?.enumerable) {        // 1. Let typedKey be key converted to an IDL value of type K.        const typedKey = keyConverter(key, prefix, argument)         // 2. Let value be ? Get(O, key).        // 3. Let typedValue be value converted to an IDL value of type V.        const typedValue = valueConverter(O[key], prefix, argument)         // 4. Set result[typedKey] to typedValue.        result[typedKey] = typedValue      }    }     // 5. Return result.    return result  }} webidl.interfaceConverter = function (TypeCheck, name) {  return (V, prefix, argument) => {    if (!TypeCheck(V)) {      throw webidl.errors.exception({        header: prefix,        message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${name}.`      })    }     return V  }} webidl.dictionaryConverter = function (converters) {  // "For each dictionary member member declared on dictionary, in lexicographical order:"  converters.sort((a, b) => (a.key > b.key) - (a.key < b.key))   return (dictionary, prefix, argument) => {    const dict = {}     if (dictionary != null && webidl.util.Type(dictionary) !== OBJECT) {      throw webidl.errors.exception({        header: prefix,        message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`      })    }     for (const options of converters) {      const { key, defaultValue, required, converter } = options       if (required === true) {        if (dictionary == null || !Object.hasOwn(dictionary, key)) {          throw webidl.errors.exception({            header: prefix,            message: `Missing required key "${key}".`          })        }      }       let value = dictionary?.[key]      const hasDefault = defaultValue !== undefined       // Only use defaultValue if value is undefined and      // a defaultValue options was provided.      if (hasDefault && value === undefined) {        value = defaultValue()      }       // A key can be optional and have no default value.      // When this happens, do not perform a conversion,      // and do not assign the key a value.      if (required || hasDefault || value !== undefined) {        value = converter(value, prefix, `${argument}.${key}`)         if (          options.allowedValues &&          !options.allowedValues.includes(value)        ) {          throw webidl.errors.exception({            header: prefix,            message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(', ')}.`          })        }         dict[key] = value      }    }     return dict  }} webidl.nullableConverter = function (converter) {  return (V, prefix, argument) => {    if (V === null) {      return V    }     return converter(V, prefix, argument)  }} /** * @param {*} value * @returns {boolean} */webidl.is.USVString = function (value) {  return (    typeof value === 'string' &&    value.isWellFormed()  )} webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream)webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob)webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams)webidl.is.File = webidl.util.MakeTypeAssertion(File)webidl.is.URL = webidl.util.MakeTypeAssertion(URL)webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal)webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort) webidl.is.BufferSource = function (V) {  return types.isArrayBuffer(V) || (    ArrayBuffer.isView(V) &&    types.isArrayBuffer(V.buffer)  )} // https://webidl.spec.whatwg.org/#dfn-get-buffer-source-copywebidl.util.getCopyOfBytesHeldByBufferSource = function (bufferSource) {  // 1. Let jsBufferSource be the result of converting bufferSource to a JavaScript value.  const jsBufferSource = bufferSource   // 2. Let jsArrayBuffer be jsBufferSource.  let jsArrayBuffer = jsBufferSource   // 3. Let offset be 0.  let offset = 0   // 4. Let length be 0.  let length = 0   // 5. If jsBufferSource has a [[ViewedArrayBuffer]] internal slot, then:  if (types.isTypedArray(jsBufferSource) || types.isDataView(jsBufferSource)) {    // 5.1. Set jsArrayBuffer to jsBufferSource.[[ViewedArrayBuffer]].    jsArrayBuffer = jsBufferSource.buffer     // 5.2. Set offset to jsBufferSource.[[ByteOffset]].    offset = jsBufferSource.byteOffset     // 5.3. Set length to jsBufferSource.[[ByteLength]].    length = jsBufferSource.byteLength  } else {    // 6. Otherwise:     // 6.1. Assert: jsBufferSource is an ArrayBuffer or SharedArrayBuffer object.    assert(types.isAnyArrayBuffer(jsBufferSource))     // 6.2. Set length to jsBufferSource.[[ArrayBufferByteLength]].    length = jsBufferSource.byteLength  }   // 7. If IsDetachedBuffer(jsArrayBuffer) is true, then return the empty byte sequence.  if (jsArrayBuffer.detached) {    return new Uint8Array(0)  }   // 8. Let bytes be a new byte sequence of length equal to length.  const bytes = new Uint8Array(length)   // 9. For i in the range offset to offset + length − 1, inclusive,  //    set bytes[i − offset] to GetValueFromBuffer(jsArrayBuffer, i, Uint8, true, Unordered).  const view = new Uint8Array(jsArrayBuffer, offset, length)  bytes.set(view)   // 10. Return bytes.  return bytes} // https://webidl.spec.whatwg.org/#es-DOMStringwebidl.converters.DOMString = function (V, prefix, argument, flags) {  // 1. If V is null and the conversion is to an IDL type  //    associated with the [LegacyNullToEmptyString]  //    extended attribute, then return the DOMString value  //    that represents the empty string.  if (V === null && webidl.util.HasFlag(flags, webidl.attributes.LegacyNullToEmptyString)) {    return ''  }   // 2. Let x be ? ToString(V).  if (typeof V === 'symbol') {    throw webidl.errors.exception({      header: prefix,      message: `${argument} is a symbol, which cannot be converted to a DOMString.`    })  }   // 3. Return the IDL DOMString value that represents the  //    same sequence of code units as the one the  //    ECMAScript String value x represents.  return String(V)} // https://webidl.spec.whatwg.org/#es-ByteStringwebidl.converters.ByteString = function (V, prefix, argument) {  // 1. Let x be ? ToString(V).  if (typeof V === 'symbol') {    throw webidl.errors.exception({      header: prefix,      message: `${argument} is a symbol, which cannot be converted to a ByteString.`    })  }   const x = String(V)   // 2. If the value of any element of x is greater than  //    255, then throw a TypeError.  for (let index = 0; index < x.length; index++) {    if (x.charCodeAt(index) > 255) {      throw new TypeError(        'Cannot convert argument to a ByteString because the character at ' +        `index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`      )    }  }   // 3. Return an IDL ByteString value whose length is the  //    length of x, and where the value of each element is  //    the value of the corresponding element of x.  return x} /** * @param {unknown} value * @returns {string} * @see https://webidl.spec.whatwg.org/#es-USVString */webidl.converters.USVString = function (value) {  // TODO: rewrite this so we can control the errors thrown  if (typeof value === 'string') {    return value.toWellFormed()  }  return `${value}`.toWellFormed()} // https://webidl.spec.whatwg.org/#es-booleanwebidl.converters.boolean = function (V) {  // 1. Let x be the result of computing ToBoolean(V).  // https://262.ecma-international.org/10.0/index.html#table-10  const x = Boolean(V)   // 2. Return the IDL boolean value that is the one that represents  //    the same truth value as the ECMAScript Boolean value x.  return x} // https://webidl.spec.whatwg.org/#es-anywebidl.converters.any = function (V) {  return V} // https://webidl.spec.whatwg.org/#es-long-longwebidl.converters['long long'] = function (V, prefix, argument) {  // 1. Let x be ? ConvertToInt(V, 64, "signed").  const x = webidl.util.ConvertToInt(V, 64, 'signed', 0, prefix, argument)   // 2. Return the IDL long long value that represents  //    the same numeric value as x.  return x} // https://webidl.spec.whatwg.org/#es-unsigned-long-longwebidl.converters['unsigned long long'] = function (V, prefix, argument) {  // 1. Let x be ? ConvertToInt(V, 64, "unsigned").  const x = webidl.util.ConvertToInt(V, 64, 'unsigned', 0, prefix, argument)   // 2. Return the IDL unsigned long long value that  //    represents the same numeric value as x.  return x} // https://webidl.spec.whatwg.org/#es-unsigned-longwebidl.converters['unsigned long'] = function (V, prefix, argument) {  // 1. Let x be ? ConvertToInt(V, 32, "unsigned").  const x = webidl.util.ConvertToInt(V, 32, 'unsigned', 0, prefix, argument)   // 2. Return the IDL unsigned long value that  //    represents the same numeric value as x.  return x} // https://webidl.spec.whatwg.org/#es-unsigned-shortwebidl.converters['unsigned short'] = function (V, prefix, argument, flags) {  // 1. Let x be ? ConvertToInt(V, 16, "unsigned").  const x = webidl.util.ConvertToInt(V, 16, 'unsigned', flags, prefix, argument)   // 2. Return the IDL unsigned short value that represents  //    the same numeric value as x.  return x} // https://webidl.spec.whatwg.org/#idl-ArrayBufferwebidl.converters.ArrayBuffer = function (V, prefix, argument, flags) {  // 1. If V is not an Object, or V does not have an  //    [[ArrayBufferData]] internal slot, then throw a  //    TypeError.  // 2. If IsSharedArrayBuffer(V) is true, then throw a  //    TypeError.  // see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances  if (    webidl.util.Type(V) !== OBJECT ||    !types.isArrayBuffer(V)  ) {    throw webidl.errors.conversionFailed({      prefix,      argument: `${argument} ("${webidl.util.Stringify(V)}")`,      types: ['ArrayBuffer']    })  }   // 3. If the conversion is not to an IDL type associated  //    with the [AllowResizable] extended attribute, and  //    IsResizableArrayBuffer(V) is true, then throw a  //    TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a resizable ArrayBuffer.`    })  }   // 4. Return the IDL ArrayBuffer value that is a  //    reference to the same object as V.  return V} // https://webidl.spec.whatwg.org/#idl-SharedArrayBufferwebidl.converters.SharedArrayBuffer = function (V, prefix, argument, flags) {  // 1. If V is not an Object, or V does not have an  //    [[ArrayBufferData]] internal slot, then throw a  //    TypeError.  // 2. If IsSharedArrayBuffer(V) is false, then throw a  //    TypeError.  // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances  if (    webidl.util.Type(V) !== OBJECT ||    !types.isSharedArrayBuffer(V)  ) {    throw webidl.errors.conversionFailed({      prefix,      argument: `${argument} ("${webidl.util.Stringify(V)}")`,      types: ['SharedArrayBuffer']    })  }   // 3. If the conversion is not to an IDL type associated  //    with the [AllowResizable] extended attribute, and  //    IsResizableArrayBuffer(V) is true, then throw a  //    TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a resizable SharedArrayBuffer.`    })  }   // 4. Return the IDL SharedArrayBuffer value that is a  //    reference to the same object as V.  return V} // https://webidl.spec.whatwg.org/#dfn-typed-array-typewebidl.converters.TypedArray = function (V, T, prefix, argument, flags) {  // 1. Let T be the IDL type V is being converted to.   // 2. If Type(V) is not Object, or V does not have a  //    [[TypedArrayName]] internal slot with a value  //    equal to T’s name, then throw a TypeError.  if (    webidl.util.Type(V) !== OBJECT ||    !types.isTypedArray(V) ||    V.constructor.name !== T.name  ) {    throw webidl.errors.conversionFailed({      prefix,      argument: `${argument} ("${webidl.util.Stringify(V)}")`,      types: [T.name]    })  }   // 3. If the conversion is not to an IDL type associated  //    with the [AllowShared] extended attribute, and  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is  //    true, then throw a TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a shared array buffer.`    })  }   // 4. If the conversion is not to an IDL type associated  //    with the [AllowResizable] extended attribute, and  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is  //    true, then throw a TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a resizable array buffer.`    })  }   // 5. Return the IDL value of type T that is a reference  //    to the same object as V.  return V} // https://webidl.spec.whatwg.org/#idl-DataViewwebidl.converters.DataView = function (V, prefix, argument, flags) {  // 1. If Type(V) is not Object, or V does not have a  //    [[DataView]] internal slot, then throw a TypeError.  if (webidl.util.Type(V) !== OBJECT || !types.isDataView(V)) {    throw webidl.errors.conversionFailed({      prefix,      argument: `${argument} ("${webidl.util.Stringify(V)}")`,      types: ['DataView']    })  }   // 2. If the conversion is not to an IDL type associated  //    with the [AllowShared] extended attribute, and  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true,  //    then throw a TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a shared array buffer.`    })  }   // 3. If the conversion is not to an IDL type associated  //    with the [AllowResizable] extended attribute, and  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is  //    true, then throw a TypeError.  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a resizable array buffer.`    })  }   // 4. Return the IDL DataView value that is a reference  //    to the same object as V.  return V} // https://webidl.spec.whatwg.org/#ArrayBufferViewwebidl.converters.ArrayBufferView = function (V, prefix, argument, flags) {  if (    webidl.util.Type(V) !== OBJECT ||    !types.isArrayBufferView(V)  ) {    throw webidl.errors.conversionFailed({      prefix,      argument: `${argument} ("${webidl.util.Stringify(V)}")`,      types: ['ArrayBufferView']    })  }   if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a shared array buffer.`    })  }   if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a view on a resizable array buffer.`    })  }   return V} // https://webidl.spec.whatwg.org/#BufferSourcewebidl.converters.BufferSource = function (V, prefix, argument, flags) {  if (types.isArrayBuffer(V)) {    return webidl.converters.ArrayBuffer(V, prefix, argument, flags)  }   if (types.isArrayBufferView(V)) {    flags &= ~webidl.attributes.AllowShared     return webidl.converters.ArrayBufferView(V, prefix, argument, flags)  }   // Make this explicit for easier debugging  if (types.isSharedArrayBuffer(V)) {    throw webidl.errors.exception({      header: prefix,      message: `${argument} cannot be a SharedArrayBuffer.`    })  }   throw webidl.errors.conversionFailed({    prefix,    argument: `${argument} ("${webidl.util.Stringify(V)}")`,    types: ['ArrayBuffer', 'ArrayBufferView']  })} // https://webidl.spec.whatwg.org/#AllowSharedBufferSourcewebidl.converters.AllowSharedBufferSource = function (V, prefix, argument, flags) {  if (types.isArrayBuffer(V)) {    return webidl.converters.ArrayBuffer(V, prefix, argument, flags)  }   if (types.isSharedArrayBuffer(V)) {    return webidl.converters.SharedArrayBuffer(V, prefix, argument, flags)  }   if (types.isArrayBufferView(V)) {    flags |= webidl.attributes.AllowShared    return webidl.converters.ArrayBufferView(V, prefix, argument, flags)  }   throw webidl.errors.conversionFailed({    prefix,    argument: `${argument} ("${webidl.util.Stringify(V)}")`,    types: ['ArrayBuffer', 'SharedArrayBuffer', 'ArrayBufferView']  })} webidl.converters['sequence<ByteString>'] = webidl.sequenceConverter(  webidl.converters.ByteString) webidl.converters['sequence<sequence<ByteString>>'] = webidl.sequenceConverter(  webidl.converters['sequence<ByteString>']) webidl.converters['record<ByteString, ByteString>'] = webidl.recordConverter(  webidl.converters.ByteString,  webidl.converters.ByteString) webidl.converters.Blob = webidl.interfaceConverter(webidl.is.Blob, 'Blob') webidl.converters.AbortSignal = webidl.interfaceConverter(  webidl.is.AbortSignal,  'AbortSignal') /** * [LegacyTreatNonObjectAsNull] * callback EventHandlerNonNull = any (Event event); * typedef EventHandlerNonNull? EventHandler; * @param {*} V */webidl.converters.EventHandlerNonNull = function (V) {  if (webidl.util.Type(V) !== OBJECT) {    return null  }   // [I]f the value is not an object, it will be converted to null, and if the value is not callable,  // it will be converted to a callback function value that does nothing when called.  if (typeof V === 'function') {    return V  }   return () => {}} webidl.attributes = {  Clamp: 1 << 0,  EnforceRange: 1 << 1,  AllowShared: 1 << 2,  AllowResizable: 1 << 3,  LegacyNullToEmptyString: 1 << 4} module.exports = {  webidl}