Upgrade Ava to v4

node_modules/cbor/lib/utils.js

@@ -0,0 +1,306 @@
+'use strict'
+
+const {Buffer} = require('buffer')
+const NoFilter = require('nofilter')
+const stream = require('stream')
+const constants = require('./constants')
+const {NUMBYTES, SHIFT32, BI, SYMS} = constants
+const MAX_SAFE_HIGH = 0x1fffff
+
+/**
+ * Convert a UTF8-encoded Buffer to a JS string.  If possible, throw an error
+ * on invalid UTF8.  Byte Order Marks are not looked at or stripped.
+ *
+ * @private
+ */
+const td = new TextDecoder('utf8', {fatal: true, ignoreBOM: true})
+exports.utf8 = buf => td.decode(buf)
+exports.utf8.checksUTF8 = true
+
+function isReadable(s) {
+  // Is this a readable stream?  In the webpack version, instanceof isn't
+  // working correctly.
+  if (s instanceof stream.Readable) {
+    return true
+  }
+  return ['read', 'on', 'pipe'].every(f => typeof s[f] === 'function')
+}
+
+exports.isBufferish = function isBufferish(b) {
+  return b &&
+    (typeof b === 'object') &&
+    ((Buffer.isBuffer(b)) ||
+      (b instanceof Uint8Array) ||
+      (b instanceof Uint8ClampedArray) ||
+      (b instanceof ArrayBuffer) ||
+      (b instanceof DataView))
+}
+
+exports.bufferishToBuffer = function bufferishToBuffer(b) {
+  if (Buffer.isBuffer(b)) {
+    return b
+  } else if (ArrayBuffer.isView(b)) {
+    return Buffer.from(b.buffer, b.byteOffset, b.byteLength)
+  } else if (b instanceof ArrayBuffer) {
+    return Buffer.from(b)
+  }
+  return null
+}
+
+exports.parseCBORint = function parseCBORint(ai, buf) {
+  switch (ai) {
+    case NUMBYTES.ONE:
+      return buf.readUInt8(0)
+    case NUMBYTES.TWO:
+      return buf.readUInt16BE(0)
+    case NUMBYTES.FOUR:
+      return buf.readUInt32BE(0)
+    case NUMBYTES.EIGHT: {
+      const f = buf.readUInt32BE(0)
+      const g = buf.readUInt32BE(4)
+      if (f > MAX_SAFE_HIGH) {
+        return (BigInt(f) * BI.SHIFT32) + BigInt(g)
+      }
+      return (f * SHIFT32) + g
+    }
+    default:
+      throw new Error(`Invalid additional info for int: ${ai}`)
+  }
+}
+
+exports.writeHalf = function writeHalf(buf, half) {
+  // Assume 0, -0, NaN, Infinity, and -Infinity have already been caught
+
+  // HACK: everyone settle in.  This isn't going to be pretty.
+  // Translate cn-cbor's C code (from Carsten Borman):
+
+  // uint32_t be32;
+  // uint16_t be16, u16;
+  // union {
+  //   float f;
+  //   uint32_t u;
+  // } u32;
+  // u32.f = float_val;
+
+  const u32 = Buffer.allocUnsafe(4)
+  u32.writeFloatBE(half, 0)
+  const u = u32.readUInt32BE(0)
+
+  // If ((u32.u & 0x1FFF) == 0) { /* worth trying half */
+
+  // hildjj: If the lower 13 bits aren't 0,
+  // we will lose precision in the conversion.
+  // mant32 = 24bits, mant16 = 11bits, 24-11 = 13
+  if ((u & 0x1FFF) !== 0) {
+    return false
+  }
+
+  // Sign, exponent, mantissa
+  //   int s16 = (u32.u >> 16) & 0x8000;
+  //   int exp = (u32.u >> 23) & 0xff;
+  //   int mant = u32.u & 0x7fffff;
+
+  let s16 = (u >> 16) & 0x8000 // Top bit is sign
+  const exp = (u >> 23) & 0xff // Then 5 bits of exponent
+  const mant = u & 0x7fffff
+
+  // Hildjj: zeros already handled.  Assert if you don't believe me.
+  //   if (exp == 0 && mant == 0)
+  //     ;              /* 0.0, -0.0 */
+
+  //   else if (exp >= 113 && exp <= 142) /* normalized */
+  //     s16 += ((exp - 112) << 10) + (mant >> 13);
+
+  if ((exp >= 113) && (exp <= 142)) {
+    s16 += ((exp - 112) << 10) + (mant >> 13)
+  } else if ((exp >= 103) && (exp < 113)) {
+    // Denormalized numbers
+    //   else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */
+    //     if (mant & ((1 << (126 - exp)) - 1))
+    //       goto float32;         /* loss of precision */
+    //     s16 += ((mant + 0x800000) >> (126 - exp));
+
+    if (mant & ((1 << (126 - exp)) - 1)) {
+      return false
+    }
+    s16 += ((mant + 0x800000) >> (126 - exp))
+  } else {
+  //   } else if (exp == 255 && mant == 0) { /* Inf */
+  //     s16 += 0x7c00;
+
+    // hildjj: Infinity already handled
+
+    //   } else
+    //     goto float32;           /* loss of range */
+
+    return false
+  }
+
+  // Done
+  //   ensure_writable(3);
+  //   u16 = s16;
+  //   be16 = hton16p((const uint8_t*)&u16);
+  buf.writeUInt16BE(s16)
+  return true
+}
+
+exports.parseHalf = function parseHalf(buf) {
+  const sign = buf[0] & 0x80 ? -1 : 1
+  const exp = (buf[0] & 0x7C) >> 2
+  const mant = ((buf[0] & 0x03) << 8) | buf[1]
+  if (!exp) {
+    return sign * 5.9604644775390625e-8 * mant
+  } else if (exp === 0x1f) {
+    return sign * (mant ? NaN : Infinity)
+  }
+  return sign * (2 ** (exp - 25)) * (1024 + mant)
+}
+
+exports.parseCBORfloat = function parseCBORfloat(buf) {
+  switch (buf.length) {
+    case 2:
+      return exports.parseHalf(buf)
+    case 4:
+      return buf.readFloatBE(0)
+    case 8:
+      return buf.readDoubleBE(0)
+    default:
+      throw new Error(`Invalid float size: ${buf.length}`)
+  }
+}
+
+exports.hex = function hex(s) {
+  return Buffer.from(s.replace(/^0x/, ''), 'hex')
+}
+
+exports.bin = function bin(s) {
+  s = s.replace(/\s/g, '')
+  let start = 0
+  let end = (s.length % 8) || 8
+  const chunks = []
+  while (end <= s.length) {
+    chunks.push(parseInt(s.slice(start, end), 2))
+    start = end
+    end += 8
+  }
+  return Buffer.from(chunks)
+}
+
+exports.arrayEqual = function arrayEqual(a, b) {
+  if ((a == null) && (b == null)) {
+    return true
+  }
+  if ((a == null) || (b == null)) {
+    return false
+  }
+  return (a.length === b.length) && a.every((elem, i) => elem === b[i])
+}
+
+exports.bufferToBigInt = function bufferToBigInt(buf) {
+  return BigInt(`0x${buf.toString('hex')}`)
+}
+
+exports.cborValueToString = function cborValueToString(val, float_bytes = -1) {
+  switch (typeof val) {
+    case 'symbol': {
+      switch (val) {
+        case SYMS.NULL:
+          return 'null'
+        case SYMS.UNDEFINED:
+          return 'undefined'
+        case SYMS.BREAK:
+          return 'BREAK'
+      }
+      // Impossible in node 10
+      /* istanbul ignore if */
+      if (val.description) {
+        return val.description
+      }
+      // On node10, Symbol doesn't have description.  Parse it out of the
+      // toString value, which looks like `Symbol(foo)`.
+      const s = val.toString()
+      const m = s.match(/^Symbol\((?<name>.*)\)/)
+      /* istanbul ignore if */
+      if (m && m.groups.name) {
+        // Impossible in node 12+
+        /* istanbul ignore next */
+        return m.groups.name
+      }
+      return 'Symbol'
+    }
+    case 'string':
+      return JSON.stringify(val)
+    case 'bigint':
+      return val.toString()
+    case 'number': {
+      const s = Object.is(val, -0) ? '-0' : String(val)
+      return (float_bytes > 0) ? `${s}_${float_bytes}` : s
+    }
+    case 'object': {
+      // A null should be caught above
+      const buf = exports.bufferishToBuffer(val)
+      if (buf) {
+        const hex = buf.toString('hex')
+        return (float_bytes === -Infinity) ? hex : `h'${hex}'`
+      }
+      if (typeof val[Symbol.for('nodejs.util.inspect.custom')] === 'function') {
+        return val[Symbol.for('nodejs.util.inspect.custom')]()
+      }
+      // Shouldn't get non-empty arrays here
+      if (Array.isArray(val)) {
+        return '[]'
+      }
+      // This should be all that is left
+      return '{}'
+    }
+  }
+  return String(val)
+}
+
+exports.guessEncoding = function guessEncoding(input, encoding) {
+  if (typeof input === 'string') {
+    return new NoFilter(input, (encoding == null) ? 'hex' : encoding)
+  }
+  const buf = exports.bufferishToBuffer(input)
+  if (buf) {
+    return new NoFilter(buf)
+  }
+  if (isReadable(input)) {
+    return input
+  }
+  throw new Error('Unknown input type')
+}
+
+const B64URL_SWAPS = {
+  '=': '',
+  '+': '-',
+  '/': '_',
+}
+
+/**
+ * @param {Buffer|Uint8Array|Uint8ClampedArray|ArrayBuffer|DataView} buf
+ *   Buffer to convert.
+ * @returns {string} Base64url string.
+ * @private
+ */
+exports.base64url = function base64url(buf) {
+  return exports.bufferishToBuffer(buf)
+    .toString('base64')
+    .replace(/[=+/]/g, c => B64URL_SWAPS[c])
+}
+
+/**
+ * @param {Buffer|Uint8Array|Uint8ClampedArray|ArrayBuffer|DataView} buf
+ *   Buffer to convert.
+ * @returns {string} Base64 string.
+ * @private
+ */
+exports.base64 = function base64(buf) {
+  return exports.bufferishToBuffer(buf).toString('base64')
+}
+
+exports.isBigEndian = function isBigEndian() {
+  const array = new Uint8Array(4)
+  const view = new Uint32Array(array.buffer)
+  return !((view[0] = 1) & array[0])
+}