@fairfox/polly 0.91.0 → 0.92.0

package/dist/tools/test/src/visual/index.js

@@ -114,12 +114,12 @@ function format(f, ...args) {
       objects.push(inspect(args[i]));
     return objects.join(" ");
   }
-  var i = 0, len = args.length, str = String(f).replace(formatRegExp, function(x2) {
-    if (x2 === "%%")
+  var i = 0, len = args.length, str = String(f).replace(formatRegExp, function(x) {
+    if (x === "%%")
       return "%";
     if (i >= len)
-      return x2;
-    switch (x2) {
+      return x;
+    switch (x) {
       case "%s":
         return String(args[i++]);
       case "%d":
@@ -131,7 +131,7 @@ function format(f, ...args) {
           return "[Circular]";
         }
       default:
-        return x2;
+        return x;
     }
   });
   for (var x = args[i];i < len; x = args[++i])
@@ -405,8 +405,8 @@ function callbackify(original) {
     var maybeCb = args.pop();
     if (typeof maybeCb !== "function")
       throw TypeError("The last argument must be of type Function");
-    var self = this, cb = function(...args2) {
-      return maybeCb.apply(self, ...args2);
+    var self = this, cb = function(...args) {
+      return maybeCb.apply(self, ...args);
     };
     original.apply(this, args).then(function(ret) {
       process.nextTick(cb.bind(null, null, ret));
@@ -503,26 +503,26 @@ __export(exports_buffer, {
   transcode: () => transcode
 });
 function getLens(b64) {
-  var len2 = b64.length;
-  if (len2 % 4 > 0)
+  var len = b64.length;
+  if (len % 4 > 0)
     throw Error("Invalid string. Length must be a multiple of 4");
   var validLen = b64.indexOf("=");
   if (validLen === -1)
-    validLen = len2;
-  var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+    validLen = len;
+  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
   return [validLen, placeHoldersLen];
 }
 function _byteLength(validLen, placeHoldersLen) {
   return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
 }
 function toByteArray(b64) {
-  var tmp, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Uint8Array(_byteLength(validLen, placeHoldersLen)), curByte = 0, len2 = placeHoldersLen > 0 ? validLen - 4 : validLen, i2;
-  for (i2 = 0;i2 < len2; i2 += 4)
-    tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)], arr[curByte++] = tmp >> 16 & 255, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
+  var tmp, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Uint8Array(_byteLength(validLen, placeHoldersLen)), curByte = 0, len = placeHoldersLen > 0 ? validLen - 4 : validLen, i;
+  for (i = 0;i < len; i += 4)
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)], arr[curByte++] = tmp >> 16 & 255, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
   if (placeHoldersLen === 2)
-    tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4, arr[curByte++] = tmp & 255;
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4, arr[curByte++] = tmp & 255;
   if (placeHoldersLen === 1)
-    tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
   return arr;
 }
 function tripletToBase64(num) {
@@ -530,27 +530,27 @@ function tripletToBase64(num) {
 }
 function encodeChunk(uint8, start, end) {
   var tmp, output = [];
-  for (var i2 = start;i2 < end; i2 += 3)
-    tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255), output.push(tripletToBase64(tmp));
+  for (var i = start;i < end; i += 3)
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255), output.push(tripletToBase64(tmp));
   return output.join("");
 }
 function fromByteArray(uint8) {
-  var tmp, len2 = uint8.length, extraBytes = len2 % 3, parts = [], maxChunkLength = 16383;
-  for (var i2 = 0, len22 = len2 - extraBytes;i2 < len22; i2 += maxChunkLength)
-    parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+  var tmp, len = uint8.length, extraBytes = len % 3, parts = [], maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes;i < len2; i += maxChunkLength)
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
   if (extraBytes === 1)
-    tmp = uint8[len2 - 1], parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+    tmp = uint8[len - 1], parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
   else if (extraBytes === 2)
-    tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
   return parts.join("");
 }
 function read(buffer, offset, isLE, mLen, nBytes) {
-  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i2];
-  i2 += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
-  for (;nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i];
+  i += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
+  for (;nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8)
     ;
   m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen;
-  for (;nBits > 0; m = m * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+  for (;nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8)
     ;
   if (e === 0)
     e = 1 - eBias;
@@ -561,7 +561,7 @@ function read(buffer, offset, isLE, mLen, nBytes) {
   return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
 }
 function write(buffer, value, offset, isLE, mLen, nBytes) {
-  var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+  var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
   if (value = Math.abs(value), isNaN(value) || value === 1 / 0)
     m = isNaN(value) ? 1 : 0, e = eMax;
   else {
@@ -580,12 +580,12 @@ function write(buffer, value, offset, isLE, mLen, nBytes) {
     else
       m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0;
   }
-  for (;mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8)
+  for (;mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8)
     ;
   e = e << mLen | m, eLen += mLen;
-  for (;eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8)
+  for (;eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8)
     ;
-  buffer[offset + i2 - d] |= s * 128;
+  buffer[offset + i - d] |= s * 128;
 }
 function createBuffer(length) {
   if (length > kMaxLength)
@@ -669,8 +669,8 @@ function fromString(string, encoding) {
 }
 function fromArrayLike(array) {
   let length = array.length < 0 ? 0 : checked(array.length) | 0, buf = createBuffer(length);
-  for (let i2 = 0;i2 < length; i2 += 1)
-    buf[i2] = array[i2] & 255;
+  for (let i = 0;i < length; i += 1)
+    buf[i] = array[i] & 255;
   return buf;
 }
 function fromArrayView(arrayView) {
@@ -696,10 +696,10 @@ function fromArrayBuffer(array, byteOffset, length) {
 }
 function fromObject(obj) {
   if (Buffer2.isBuffer(obj)) {
-    let len2 = checked(obj.length) | 0, buf = createBuffer(len2);
+    let len = checked(obj.length) | 0, buf = createBuffer(len);
     if (buf.length === 0)
       return buf;
-    return obj.copy(buf, 0, 0, len2), buf;
+    return obj.copy(buf, 0, 0, len), buf;
   }
   if (obj.length !== undefined) {
     if (typeof obj.length !== "number" || Number.isNaN(obj.length))
@@ -721,8 +721,8 @@ function byteLength(string, encoding) {
     return string.byteLength;
   if (typeof string !== "string")
     throw TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
-  let len2 = string.length, mustMatch = arguments.length > 2 && arguments[2] === true;
-  if (!mustMatch && len2 === 0)
+  let len = string.length, mustMatch = arguments.length > 2 && arguments[2] === true;
+  if (!mustMatch && len === 0)
     return 0;
   let loweredCase = false;
   for (;; )
@@ -730,7 +730,7 @@ function byteLength(string, encoding) {
       case "ascii":
       case "latin1":
       case "binary":
-        return len2;
+        return len;
       case "utf8":
       case "utf-8":
         return utf8ToBytes(string).length;
@@ -738,9 +738,9 @@ function byteLength(string, encoding) {
       case "ucs-2":
       case "utf16le":
       case "utf-16le":
-        return len2 * 2;
+        return len * 2;
       case "hex":
-        return len2 >>> 1;
+        return len >>> 1;
       case "base64":
         return base64ToBytes(string).length;
       default:
@@ -789,8 +789,8 @@ function slowToString(encoding, start, end) {
     }
 }
 function swap(b, n, m) {
-  let i2 = b[n];
-  b[n] = b[m], b[m] = i2;
+  let i = b[n];
+  b[n] = b[m], b[m] = i;
 }
 function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
   if (buffer.length === 0)
@@ -840,38 +840,38 @@ function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
       indexSize = 2, arrLength /= 2, valLength /= 2, byteOffset /= 2;
     }
   }
-  function read2(buf, i3) {
+  function read(buf, i) {
     if (indexSize === 1)
-      return buf[i3];
+      return buf[i];
     else
-      return buf.readUInt16BE(i3 * indexSize);
+      return buf.readUInt16BE(i * indexSize);
   }
-  let i2;
+  let i;
   if (dir) {
     let foundIndex = -1;
-    for (i2 = byteOffset;i2 < arrLength; i2++)
-      if (read2(arr, i2) === read2(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
+    for (i = byteOffset;i < arrLength; i++)
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
         if (foundIndex === -1)
-          foundIndex = i2;
-        if (i2 - foundIndex + 1 === valLength)
+          foundIndex = i;
+        if (i - foundIndex + 1 === valLength)
           return foundIndex * indexSize;
       } else {
         if (foundIndex !== -1)
-          i2 -= i2 - foundIndex;
+          i -= i - foundIndex;
         foundIndex = -1;
       }
   } else {
     if (byteOffset + valLength > arrLength)
       byteOffset = arrLength - valLength;
-    for (i2 = byteOffset;i2 >= 0; i2--) {
+    for (i = byteOffset;i >= 0; i--) {
       let found = true;
       for (let j = 0;j < valLength; j++)
-        if (read2(arr, i2 + j) !== read2(val, j)) {
+        if (read(arr, i + j) !== read(val, j)) {
           found = false;
           break;
         }
       if (found)
-        return i2;
+        return i;
     }
   }
   return -1;
@@ -886,14 +886,14 @@ function hexWrite(buf, string, offset, length) {
   let strLen = string.length;
   if (length > strLen / 2)
     length = strLen / 2;
-  let i2;
-  for (i2 = 0;i2 < length; ++i2) {
-    let parsed = parseInt(string.substr(i2 * 2, 2), 16);
+  let i;
+  for (i = 0;i < length; ++i) {
+    let parsed = parseInt(string.substr(i * 2, 2), 16);
     if (Number.isNaN(parsed))
-      return i2;
-    buf[offset + i2] = parsed;
+      return i;
+    buf[offset + i] = parsed;
   }
-  return i2;
+  return i;
 }
 function utf8Write(buf, string, offset, length) {
   return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
@@ -915,10 +915,10 @@ function base64Slice(buf, start, end) {
 }
 function utf8Slice(buf, start, end) {
   end = Math.min(buf.length, end);
-  let res = [], i2 = start;
-  while (i2 < end) {
-    let firstByte = buf[i2], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-    if (i2 + bytesPerSequence <= end) {
+  let res = [], i = start;
+  while (i < end) {
+    let firstByte = buf[i], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+    if (i + bytesPerSequence <= end) {
       let secondByte, thirdByte, fourthByte, tempCodePoint;
       switch (bytesPerSequence) {
         case 1:
@@ -926,19 +926,19 @@ function utf8Slice(buf, start, end) {
             codePoint = firstByte;
           break;
         case 2:
-          if (secondByte = buf[i2 + 1], (secondByte & 192) === 128) {
+          if (secondByte = buf[i + 1], (secondByte & 192) === 128) {
             if (tempCodePoint = (firstByte & 31) << 6 | secondByte & 63, tempCodePoint > 127)
               codePoint = tempCodePoint;
           }
           break;
         case 3:
-          if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+          if (secondByte = buf[i + 1], thirdByte = buf[i + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128) {
             if (tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63, tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343))
               codePoint = tempCodePoint;
           }
           break;
         case 4:
-          if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], fourthByte = buf[i2 + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+          if (secondByte = buf[i + 1], thirdByte = buf[i + 2], fourthByte = buf[i + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
             if (tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63, tempCodePoint > 65535 && tempCodePoint < 1114112)
               codePoint = tempCodePoint;
           }
@@ -948,48 +948,48 @@ function utf8Slice(buf, start, end) {
       codePoint = 65533, bytesPerSequence = 1;
     else if (codePoint > 65535)
       codePoint -= 65536, res.push(codePoint >>> 10 & 1023 | 55296), codePoint = 56320 | codePoint & 1023;
-    res.push(codePoint), i2 += bytesPerSequence;
+    res.push(codePoint), i += bytesPerSequence;
   }
   return decodeCodePointsArray(res);
 }
 function decodeCodePointsArray(codePoints) {
-  let len2 = codePoints.length;
-  if (len2 <= MAX_ARGUMENTS_LENGTH)
+  let len = codePoints.length;
+  if (len <= MAX_ARGUMENTS_LENGTH)
     return String.fromCharCode.apply(String, codePoints);
-  let res = "", i2 = 0;
-  while (i2 < len2)
-    res += String.fromCharCode.apply(String, codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH));
+  let res = "", i = 0;
+  while (i < len)
+    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
   return res;
 }
 function asciiSlice(buf, start, end) {
   let ret = "";
   end = Math.min(buf.length, end);
-  for (let i2 = start;i2 < end; ++i2)
-    ret += String.fromCharCode(buf[i2] & 127);
+  for (let i = start;i < end; ++i)
+    ret += String.fromCharCode(buf[i] & 127);
   return ret;
 }
 function latin1Slice(buf, start, end) {
   let ret = "";
   end = Math.min(buf.length, end);
-  for (let i2 = start;i2 < end; ++i2)
-    ret += String.fromCharCode(buf[i2]);
+  for (let i = start;i < end; ++i)
+    ret += String.fromCharCode(buf[i]);
   return ret;
 }
 function hexSlice(buf, start, end) {
-  let len2 = buf.length;
+  let len = buf.length;
   if (!start || start < 0)
     start = 0;
-  if (!end || end < 0 || end > len2)
-    end = len2;
+  if (!end || end < 0 || end > len)
+    end = len;
   let out = "";
-  for (let i2 = start;i2 < end; ++i2)
-    out += hexSliceLookupTable[buf[i2]];
+  for (let i = start;i < end; ++i)
+    out += hexSliceLookupTable[buf[i]];
   return out;
 }
 function utf16leSlice(buf, start, end) {
   let bytes = buf.slice(start, end), res = "";
-  for (let i2 = 0;i2 < bytes.length - 1; i2 += 2)
-    res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
+  for (let i = 0;i < bytes.length - 1; i += 2)
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
   return res;
 }
 function checkOffset(offset, ext, length) {
@@ -1037,28 +1037,28 @@ function writeDouble(buf, value, offset, littleEndian, noAssert) {
   return write(buf, value, offset, littleEndian, 52, 8), offset + 8;
 }
 function addNumericalSeparator(val) {
-  let res = "", i2 = val.length, start = val[0] === "-" ? 1 : 0;
-  for (;i2 >= start + 4; i2 -= 3)
-    res = `_${val.slice(i2 - 3, i2)}${res}`;
-  return `${val.slice(0, i2)}${res}`;
+  let res = "", i = val.length, start = val[0] === "-" ? 1 : 0;
+  for (;i >= start + 4; i -= 3)
+    res = `_${val.slice(i - 3, i)}${res}`;
+  return `${val.slice(0, i)}${res}`;
 }
-function checkBounds(buf, offset, byteLength2) {
-  if (validateNumber(offset, "offset"), buf[offset] === undefined || buf[offset + byteLength2] === undefined)
-    boundsError(offset, buf.length - (byteLength2 + 1));
+function checkBounds(buf, offset, byteLength) {
+  if (validateNumber(offset, "offset"), buf[offset] === undefined || buf[offset + byteLength] === undefined)
+    boundsError(offset, buf.length - (byteLength + 1));
 }
-function checkIntBI(value, min, max, buf, offset, byteLength2) {
+function checkIntBI(value, min, max, buf, offset, byteLength) {
   if (value > max || value < min) {
     let n = typeof min === "bigint" ? "n" : "", range;
-    if (byteLength2 > 3)
+    if (byteLength > 3)
       if (min === 0 || min === BigInt(0))
-        range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
       else
-        range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength + 1) * 8 - 1}${n}`;
     else
       range = `>= ${min}${n} and <= ${max}${n}`;
     throw new ERR_OUT_OF_RANGE("value", range, value);
   }
-  checkBounds(buf, offset, byteLength2);
+  checkBounds(buf, offset, byteLength);
 }
 function validateNumber(value, name) {
   if (typeof value !== "number")
@@ -1081,14 +1081,14 @@ function base64clean(str) {
 function utf8ToBytes(string, units) {
   units = units || 1 / 0;
   let codePoint, length = string.length, leadSurrogate = null, bytes = [];
-  for (let i2 = 0;i2 < length; ++i2) {
-    if (codePoint = string.charCodeAt(i2), codePoint > 55295 && codePoint < 57344) {
+  for (let i = 0;i < length; ++i) {
+    if (codePoint = string.charCodeAt(i), codePoint > 55295 && codePoint < 57344) {
       if (!leadSurrogate) {
         if (codePoint > 56319) {
           if ((units -= 3) > -1)
             bytes.push(239, 191, 189);
           continue;
-        } else if (i2 + 1 === length) {
+        } else if (i + 1 === length) {
           if ((units -= 3) > -1)
             bytes.push(239, 191, 189);
           continue;
@@ -1130,16 +1130,16 @@ function utf8ToBytes(string, units) {
 }
 function asciiToBytes(str) {
   let byteArray = [];
-  for (let i2 = 0;i2 < str.length; ++i2)
-    byteArray.push(str.charCodeAt(i2) & 255);
+  for (let i = 0;i < str.length; ++i)
+    byteArray.push(str.charCodeAt(i) & 255);
   return byteArray;
 }
 function utf16leToBytes(str, units) {
   let c, hi, lo, byteArray = [];
-  for (let i2 = 0;i2 < str.length; ++i2) {
+  for (let i = 0;i < str.length; ++i) {
     if ((units -= 2) < 0)
       break;
-    c = str.charCodeAt(i2), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
+    c = str.charCodeAt(i), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
   }
   return byteArray;
 }
@@ -1147,13 +1147,13 @@ function base64ToBytes(str) {
   return toByteArray(base64clean(str));
 }
 function blitBuffer(src, dst, offset, length) {
-  let i2;
-  for (i2 = 0;i2 < length; ++i2) {
-    if (i2 + offset >= dst.length || i2 >= src.length)
+  let i;
+  for (i = 0;i < length; ++i) {
+    if (i + offset >= dst.length || i >= src.length)
       break;
-    dst[i2 + offset] = src[i2];
+    dst[i + offset] = src[i];
   }
-  return i2;
+  return i;
 }
 function isInstance(obj, type) {
   return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
@@ -1183,10 +1183,7 @@ var init_buffer = __esm(() => {
   revLookup[45] = 62;
   revLookup[95] = 63;
   customInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
-  btoa = globalThis.btoa;
-  atob = globalThis.atob;
-  File = globalThis.File;
-  Blob = globalThis.Blob;
+  ({ btoa, atob, File, Blob } = globalThis);
   constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
   ERR_BUFFER_OUT_OF_BOUNDS = E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
     if (name)
@@ -1245,9 +1242,9 @@ var init_buffer = __esm(() => {
     if (a === b)
       return 0;
     let x = a.length, y = b.length;
-    for (let i2 = 0, len2 = Math.min(x, y);i2 < len2; ++i2)
-      if (a[i2] !== b[i2]) {
-        x = a[i2], y = b[i2];
+    for (let i = 0, len = Math.min(x, y);i < len; ++i)
+      if (a[i] !== b[i]) {
+        x = a[i], y = b[i];
         break;
       }
     if (x < y)
@@ -1279,15 +1276,15 @@ var init_buffer = __esm(() => {
       throw TypeError('"list" argument must be an Array of Buffers');
     if (list.length === 0)
       return Buffer2.alloc(0);
-    let i2;
+    let i;
     if (length === undefined) {
       length = 0;
-      for (i2 = 0;i2 < list.length; ++i2)
-        length += list[i2].length;
+      for (i = 0;i < list.length; ++i)
+        length += list[i].length;
     }
     let buffer = Buffer2.allocUnsafe(length), pos = 0;
-    for (i2 = 0;i2 < list.length; ++i2) {
-      let buf = list[i2];
+    for (i = 0;i < list.length; ++i) {
+      let buf = list[i];
       if (isInstance(buf, Uint8Array))
         if (pos + buf.length > buffer.length) {
           if (!Buffer2.isBuffer(buf))
@@ -1306,27 +1303,27 @@ var init_buffer = __esm(() => {
   Buffer2.byteLength = byteLength;
   Buffer2.prototype._isBuffer = true;
   Buffer2.prototype.swap16 = function() {
-    let len2 = this.length;
-    if (len2 % 2 !== 0)
+    let len = this.length;
+    if (len % 2 !== 0)
       throw RangeError("Buffer size must be a multiple of 16-bits");
-    for (let i2 = 0;i2 < len2; i2 += 2)
-      swap(this, i2, i2 + 1);
+    for (let i = 0;i < len; i += 2)
+      swap(this, i, i + 1);
     return this;
   };
   Buffer2.prototype.swap32 = function() {
-    let len2 = this.length;
-    if (len2 % 4 !== 0)
+    let len = this.length;
+    if (len % 4 !== 0)
       throw RangeError("Buffer size must be a multiple of 32-bits");
-    for (let i2 = 0;i2 < len2; i2 += 4)
-      swap(this, i2, i2 + 3), swap(this, i2 + 1, i2 + 2);
+    for (let i = 0;i < len; i += 4)
+      swap(this, i, i + 3), swap(this, i + 1, i + 2);
     return this;
   };
   Buffer2.prototype.swap64 = function() {
-    let len2 = this.length;
-    if (len2 % 8 !== 0)
+    let len = this.length;
+    if (len % 8 !== 0)
       throw RangeError("Buffer size must be a multiple of 64-bits");
-    for (let i2 = 0;i2 < len2; i2 += 8)
-      swap(this, i2, i2 + 7), swap(this, i2 + 1, i2 + 6), swap(this, i2 + 2, i2 + 5), swap(this, i2 + 3, i2 + 4);
+    for (let i = 0;i < len; i += 8)
+      swap(this, i, i + 7), swap(this, i + 1, i + 6), swap(this, i + 2, i + 5), swap(this, i + 3, i + 4);
     return this;
   };
   Buffer2.prototype.toString = function() {
@@ -1376,10 +1373,10 @@ var init_buffer = __esm(() => {
       return 1;
     if (start >>>= 0, end >>>= 0, thisStart >>>= 0, thisEnd >>>= 0, this === target)
       return 0;
-    let x = thisEnd - thisStart, y = end - start, len2 = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
-    for (let i2 = 0;i2 < len2; ++i2)
-      if (thisCopy[i2] !== targetCopy[i2]) {
-        x = thisCopy[i2], y = targetCopy[i2];
+    let x = thisEnd - thisStart, y = end - start, len = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
+    for (let i = 0;i < len; ++i)
+      if (thisCopy[i] !== targetCopy[i]) {
+        x = thisCopy[i], y = targetCopy[i];
         break;
       }
     if (x < y)
@@ -1446,36 +1443,36 @@ var init_buffer = __esm(() => {
     return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
   };
   Buffer2.prototype.slice = function(start, end) {
-    let len2 = this.length;
-    if (start = ~~start, end = end === undefined ? len2 : ~~end, start < 0) {
-      if (start += len2, start < 0)
+    let len = this.length;
+    if (start = ~~start, end = end === undefined ? len : ~~end, start < 0) {
+      if (start += len, start < 0)
         start = 0;
-    } else if (start > len2)
-      start = len2;
+    } else if (start > len)
+      start = len;
     if (end < 0) {
-      if (end += len2, end < 0)
+      if (end += len, end < 0)
         end = 0;
-    } else if (end > len2)
-      end = len2;
+    } else if (end > len)
+      end = len;
     if (end < start)
       end = start;
     let newBuf = this.subarray(start, end);
     return Object.setPrototypeOf(newBuf, Buffer2.prototype), newBuf;
   };
-  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
-    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
-      checkOffset(offset, byteLength2, this.length);
-    let val = this[offset], mul = 1, i2 = 0;
-    while (++i2 < byteLength2 && (mul *= 256))
-      val += this[offset + i2] * mul;
+  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength, noAssert) {
+    if (offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert)
+      checkOffset(offset, byteLength, this.length);
+    let val = this[offset], mul = 1, i = 0;
+    while (++i < byteLength && (mul *= 256))
+      val += this[offset + i] * mul;
     return val;
   };
-  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
-    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
-      checkOffset(offset, byteLength2, this.length);
-    let val = this[offset + --byteLength2], mul = 1;
-    while (byteLength2 > 0 && (mul *= 256))
-      val += this[offset + --byteLength2] * mul;
+  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength, noAssert) {
+    if (offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert)
+      checkOffset(offset, byteLength, this.length);
+    let val = this[offset + --byteLength], mul = 1;
+    while (byteLength > 0 && (mul *= 256))
+      val += this[offset + --byteLength] * mul;
     return val;
   };
   Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
@@ -1519,24 +1516,24 @@ var init_buffer = __esm(() => {
     let hi = first * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + this[++offset], lo = this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last;
     return (BigInt(hi) << BigInt(32)) + BigInt(lo);
   });
-  Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
-    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
-      checkOffset(offset, byteLength2, this.length);
-    let val = this[offset], mul = 1, i2 = 0;
-    while (++i2 < byteLength2 && (mul *= 256))
-      val += this[offset + i2] * mul;
+  Buffer2.prototype.readIntLE = function(offset, byteLength, noAssert) {
+    if (offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert)
+      checkOffset(offset, byteLength, this.length);
+    let val = this[offset], mul = 1, i = 0;
+    while (++i < byteLength && (mul *= 256))
+      val += this[offset + i] * mul;
     if (mul *= 128, val >= mul)
-      val -= Math.pow(2, 8 * byteLength2);
+      val -= Math.pow(2, 8 * byteLength);
     return val;
   };
-  Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
-    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
-      checkOffset(offset, byteLength2, this.length);
-    let i2 = byteLength2, mul = 1, val = this[offset + --i2];
-    while (i2 > 0 && (mul *= 256))
-      val += this[offset + --i2] * mul;
+  Buffer2.prototype.readIntBE = function(offset, byteLength, noAssert) {
+    if (offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert)
+      checkOffset(offset, byteLength, this.length);
+    let i = byteLength, mul = 1, val = this[offset + --i];
+    while (i > 0 && (mul *= 256))
+      val += this[offset + --i] * mul;
     if (mul *= 128, val >= mul)
-      val -= Math.pow(2, 8 * byteLength2);
+      val -= Math.pow(2, 8 * byteLength);
     return val;
   };
   Buffer2.prototype.readInt8 = function(offset, noAssert) {
@@ -1604,27 +1601,27 @@ var init_buffer = __esm(() => {
       checkOffset(offset, 8, this.length);
     return read(this, offset, false, 52, 8);
   };
-  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength2, noAssert) {
-    if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
-      let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength, noAssert) {
+    if (value = +value, offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert) {
+      let maxBytes = Math.pow(2, 8 * byteLength) - 1;
+      checkInt(this, value, offset, byteLength, maxBytes, 0);
     }
-    let mul = 1, i2 = 0;
+    let mul = 1, i = 0;
     this[offset] = value & 255;
-    while (++i2 < byteLength2 && (mul *= 256))
-      this[offset + i2] = value / mul & 255;
-    return offset + byteLength2;
+    while (++i < byteLength && (mul *= 256))
+      this[offset + i] = value / mul & 255;
+    return offset + byteLength;
   };
-  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength2, noAssert) {
-    if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
-      let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength, noAssert) {
+    if (value = +value, offset = offset >>> 0, byteLength = byteLength >>> 0, !noAssert) {
+      let maxBytes = Math.pow(2, 8 * byteLength) - 1;
+      checkInt(this, value, offset, byteLength, maxBytes, 0);
     }
-    let i2 = byteLength2 - 1, mul = 1;
-    this[offset + i2] = value & 255;
-    while (--i2 >= 0 && (mul *= 256))
-      this[offset + i2] = value / mul & 255;
-    return offset + byteLength2;
+    let i = byteLength - 1, mul = 1;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256))
+      this[offset + i] = value / mul & 255;
+    return offset + byteLength;
   };
   Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
@@ -1657,33 +1654,33 @@ var init_buffer = __esm(() => {
   Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function(value, offset = 0) {
     return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
   });
-  Buffer2.prototype.writeIntLE = function(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeIntLE = function(value, offset, byteLength, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert) {
-      let limit = Math.pow(2, 8 * byteLength2 - 1);
-      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      let limit = Math.pow(2, 8 * byteLength - 1);
+      checkInt(this, value, offset, byteLength, limit - 1, -limit);
     }
-    let i2 = 0, mul = 1, sub = 0;
+    let i = 0, mul = 1, sub = 0;
     this[offset] = value & 255;
-    while (++i2 < byteLength2 && (mul *= 256)) {
-      if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0)
+    while (++i < byteLength && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0)
         sub = 1;
-      this[offset + i2] = (value / mul >> 0) - sub & 255;
+      this[offset + i] = (value / mul >> 0) - sub & 255;
     }
-    return offset + byteLength2;
+    return offset + byteLength;
   };
-  Buffer2.prototype.writeIntBE = function(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeIntBE = function(value, offset, byteLength, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert) {
-      let limit = Math.pow(2, 8 * byteLength2 - 1);
-      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      let limit = Math.pow(2, 8 * byteLength - 1);
+      checkInt(this, value, offset, byteLength, limit - 1, -limit);
     }
-    let i2 = byteLength2 - 1, mul = 1, sub = 0;
-    this[offset + i2] = value & 255;
-    while (--i2 >= 0 && (mul *= 256)) {
-      if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0)
+    let i = byteLength - 1, mul = 1, sub = 0;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0)
         sub = 1;
-      this[offset + i2] = (value / mul >> 0) - sub & 255;
+      this[offset + i] = (value / mul >> 0) - sub & 255;
     }
-    return offset + byteLength2;
+    return offset + byteLength;
   };
   Buffer2.prototype.writeInt8 = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
@@ -1759,12 +1756,12 @@ var init_buffer = __esm(() => {
       end = this.length;
     if (target.length - targetStart < end - start)
       end = target.length - targetStart + start;
-    let len2 = end - start;
+    let len = end - start;
     if (this === target && typeof Uint8Array.prototype.copyWithin === "function")
       this.copyWithin(targetStart, start, end);
     else
       Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
-    return len2;
+    return len;
   };
   Buffer2.prototype.fill = function(val, start, end, encoding) {
     if (typeof val === "string") {
@@ -1777,9 +1774,9 @@ var init_buffer = __esm(() => {
       if (typeof encoding === "string" && !Buffer2.isEncoding(encoding))
         throw TypeError("Unknown encoding: " + encoding);
       if (val.length === 1) {
-        let code2 = val.charCodeAt(0);
-        if (encoding === "utf8" && code2 < 128 || encoding === "latin1")
-          val = code2;
+        let code = val.charCodeAt(0);
+        if (encoding === "utf8" && code < 128 || encoding === "latin1")
+          val = code;
       }
     } else if (typeof val === "number")
       val = val & 255;
@@ -1791,26 +1788,26 @@ var init_buffer = __esm(() => {
       return this;
     if (start = start >>> 0, end = end === undefined ? this.length : end >>> 0, !val)
       val = 0;
-    let i2;
+    let i;
     if (typeof val === "number")
-      for (i2 = start;i2 < end; ++i2)
-        this[i2] = val;
+      for (i = start;i < end; ++i)
+        this[i] = val;
     else {
-      let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len2 = bytes.length;
-      if (len2 === 0)
+      let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len = bytes.length;
+      if (len === 0)
         throw TypeError('The value "' + val + '" is invalid for argument "value"');
-      for (i2 = 0;i2 < end - start; ++i2)
-        this[i2 + start] = bytes[i2 % len2];
+      for (i = 0;i < end - start; ++i)
+        this[i + start] = bytes[i % len];
     }
     return this;
   };
   INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
   hexSliceLookupTable = function() {
     let table = Array(256);
-    for (let i2 = 0;i2 < 16; ++i2) {
-      let i16 = i2 * 16;
+    for (let i = 0;i < 16; ++i) {
+      let i16 = i * 16;
       for (let j = 0;j < 16; ++j)
-        table[i16 + j] = "0123456789abcdef"[i2] + "0123456789abcdef"[j];
+        table[i16 + j] = "0123456789abcdef"[i] + "0123456789abcdef"[j];
     }
     return table;
   }();
@@ -1864,7 +1861,7 @@ function overflowWarning(emitter, type, handlers) {
 function onceWrapper(type, listener, ...args) {
   this.removeListener(type, listener), listener.apply(this, args);
 }
-function once2(emitter, type, options) {
+function once(emitter, type, options) {
   var signal = options?.signal;
   if (validateAbortSignal(signal, "options.signal"), signal?.aborted)
     throw new AbortError(undefined, { cause: signal?.reason });
@@ -1892,7 +1889,7 @@ function once2(emitter, type, options) {
 function getEventListeners(emitter, type) {
   return emitter.listeners(type);
 }
-function setMaxListeners2(n, ...eventTargets) {
+function setMaxListeners(n, ...eventTargets) {
   validateNumber2(n, "setMaxListeners", 0);
   var length;
   if (eventTargets && (length = eventTargets.length))
@@ -1901,7 +1898,7 @@ function setMaxListeners2(n, ...eventTargets) {
   else
     defaultMaxListeners = n;
 }
-function listenerCount2(emitter, type) {
+function listenerCount(emitter, type) {
   return emitter.listenerCount(type);
 }
 function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
@@ -1945,7 +1942,7 @@ function validateBoolean(value, name) {
   if (typeof value !== "boolean")
     throw ERR_INVALID_ARG_TYPE2(name, "boolean", value);
 }
-function getMaxListeners2(emitterOrTarget) {
+function getMaxListeners(emitterOrTarget) {
   return emitterOrTarget?._maxListeners ?? defaultMaxListeners;
 }
 function addAbortListener(signal, listener) {
@@ -2177,18 +2174,16 @@ var init_events = __esm(() => {
     return EventEmitterPrototype[kCapture];
   }, set(value) {
     validateBoolean(value, "EventEmitter.captureRejections"), EventEmitterPrototype[kCapture] = value;
-  }, enumerable: true }, defaultMaxListeners: { enumerable: true, get: () => {
-    return defaultMaxListeners;
-  }, set: (arg) => {
+  }, enumerable: true }, defaultMaxListeners: { enumerable: true, get: () => defaultMaxListeners, set: (arg) => {
     validateNumber2(arg, "defaultMaxListeners", 0), defaultMaxListeners = arg;
   } }, kMaxEventTargetListeners: { value: kMaxEventTargetListeners, enumerable: false, configurable: false, writable: false }, kMaxEventTargetListenersWarned: { value: kMaxEventTargetListenersWarned, enumerable: false, configurable: false, writable: false } });
-  Object.assign(EventEmitter, { once: once2, getEventListeners, getMaxListeners: getMaxListeners2, setMaxListeners: setMaxListeners2, EventEmitter, usingDomains: false, captureRejectionSymbol, errorMonitor: kErrorMonitor, addAbortListener, init: EventEmitter, listenerCount: listenerCount2 });
+  Object.assign(EventEmitter, { once, getEventListeners, getMaxListeners, setMaxListeners, EventEmitter, usingDomains: false, captureRejectionSymbol, errorMonitor: kErrorMonitor, addAbortListener, init: EventEmitter, listenerCount });
 });
 
 // node:stream
 var require_stream = __commonJS(function(exports, module) {
   var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-  var require_primordials = __commonJS2((exports2, module2) => {
+  var require_primordials = __commonJS2(function(exports2, module2) {
 
     class AggregateError2 extends Error {
       constructor(errors) {
@@ -2254,7 +2249,7 @@ var require_stream = __commonJS(function(exports, module) {
       return self.set(buf, len);
     }, Boolean, Uint8Array };
   });
-  var require_inspect = __commonJS2((exports2, module2) => {
+  var require_inspect = __commonJS2(function(exports2, module2) {
     module2.exports = { format(format, ...args) {
       return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
         let replacement = args.shift();
@@ -2293,7 +2288,7 @@ var require_stream = __commonJS(function(exports, module) {
       }
     } };
   });
-  var require_errors = __commonJS2((exports2, module2) => {
+  var require_errors = __commonJS2(function(exports2, module2) {
     var { format, inspect } = require_inspect(), { AggregateError: CustomAggregateError } = require_primordials(), AggregateError2 = globalThis.AggregateError || CustomAggregateError, kIsNodeError = Symbol("kIsNodeError"), kTypes = ["string", "function", "number", "object", "Function", "Object", "boolean", "bigint", "symbol"], classRegExp = /^([A-Z][a-z0-9]*)+$/, codes = {};
     function assert(value, message) {
       if (!value)
@@ -2500,7 +2495,7 @@ var require_stream = __commonJS(function(exports, module) {
     E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError);
     module2.exports = { AbortError, aggregateTwoErrors: hideStackFrames(aggregateTwoErrors), hideStackFrames, codes };
   });
-  var require_event_target_shim = __commonJS2((exports2, module2) => {
+  var require_event_target_shim = __commonJS2(function(exports2, module2) {
     Object.defineProperty(exports2, "__esModule", { value: true });
     var privateData = new WeakMap, wrappers = new WeakMap;
     function pd(event) {
@@ -2786,7 +2781,7 @@ var require_stream = __commonJS(function(exports, module) {
     module2.exports.EventTarget = module2.exports.default = EventTarget;
     module2.exports.defineEventAttribute = defineEventAttribute;
   });
-  var require_abort_controller = __commonJS2((exports2, module2) => {
+  var require_abort_controller = __commonJS2(function(exports2, module2) {
     Object.defineProperty(exports2, "__esModule", { value: true });
     var eventTargetShim = require_event_target_shim();
 
@@ -2845,7 +2840,7 @@ var require_stream = __commonJS(function(exports, module) {
     module2.exports.AbortController = module2.exports.default = AbortController;
     module2.exports.AbortSignal = AbortSignal;
   });
-  var require_util = __commonJS2((exports2, module2) => {
+  var require_util = __commonJS2(function(exports2, module2) {
     var bufferModule = (init_buffer(), __toCommonJS(exports_buffer)), { format, inspect } = require_inspect(), { codes: { ERR_INVALID_ARG_TYPE } } = require_errors(), { kResistStopPropagation, AggregateError: AggregateError2, SymbolDispose } = require_primordials(), AbortSignal = globalThis.AbortSignal || require_abort_controller().AbortSignal, AbortController = globalThis.AbortController || require_abort_controller().AbortController, AsyncFunction = Object.getPrototypeOf(async function() {}).constructor, Blob = globalThis.Blob || bufferModule.Blob, isBlob = typeof Blob < "u" ? function(b) {
       return b instanceof Blob;
     } : function(b) {
@@ -2912,7 +2907,7 @@ var require_stream = __commonJS(function(exports, module) {
     } };
     module2.exports.promisify.custom = Symbol.for("nodejs.util.promisify.custom");
   });
-  var require_validators = __commonJS2((exports2, module2) => {
+  var require_validators = __commonJS2(function(exports2, module2) {
     var { ArrayIsArray, ArrayPrototypeIncludes, ArrayPrototypeJoin, ArrayPrototypeMap, NumberIsInteger, NumberIsNaN, NumberMAX_SAFE_INTEGER, NumberMIN_SAFE_INTEGER, NumberParseInt, ObjectPrototypeHasOwnProperty, RegExpPrototypeExec, String: String2, StringPrototypeToUpperCase, StringPrototypeTrim } = require_primordials(), { hideStackFrames, codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL } } = require_errors(), { normalizeEncoding } = require_util(), { isAsyncFunction, isArrayBufferView } = require_util().types, signals = {};
     function isInt32(value) {
       return value === (value | 0);
@@ -3072,10 +3067,10 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { isInt32, isUint32, parseFileMode, validateArray, validateStringArray, validateBooleanArray, validateAbortSignalArray, validateBoolean, validateBuffer, validateDictionary, validateEncoding, validateFunction, validateInt32, validateInteger, validateNumber, validateObject, validateOneOf, validatePlainFunction, validatePort, validateSignalName, validateString, validateUint32, validateUndefined, validateUnion, validateAbortSignal, validateLinkHeaderValue };
   });
-  var require_process = __commonJS2((exports2, module2) => {
+  var require_process = __commonJS2(function(exports2, module2) {
     module2.exports = globalThis.process;
   });
-  var require_utils = __commonJS2((exports2, module2) => {
+  var require_utils = __commonJS2(function(exports2, module2) {
     var { SymbolAsyncIterator, SymbolIterator, SymbolFor } = require_primordials(), kIsDestroyed = SymbolFor("nodejs.stream.destroyed"), kIsErrored = SymbolFor("nodejs.stream.errored"), kIsReadable = SymbolFor("nodejs.stream.readable"), kIsWritable = SymbolFor("nodejs.stream.writable"), kIsDisturbed = SymbolFor("nodejs.stream.disturbed"), kIsClosedPromise = SymbolFor("nodejs.webstream.isClosedPromise"), kControllerErrorFunction = SymbolFor("nodejs.webstream.controllerErrorFunction");
     function isReadableNodeStream(obj, strict = false) {
       var _obj$_readableState;
@@ -3247,7 +3242,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { isDestroyed, kIsDestroyed, isDisturbed, kIsDisturbed, isErrored, kIsErrored, isReadable, kIsReadable, kIsClosedPromise, kControllerErrorFunction, kIsWritable, isClosed, isDuplexNodeStream, isFinished, isIterable, isReadableNodeStream, isReadableStream, isReadableEnded, isReadableFinished, isReadableErrored, isNodeStream, isWebStream, isWritable, isWritableNodeStream, isWritableStream, isWritableEnded, isWritableFinished, isWritableErrored, isServerRequest, isServerResponse, willEmitClose, isTransformStream };
   });
-  var require_end_of_stream = __commonJS2((exports2, module2) => {
+  var require_end_of_stream = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { AbortError, codes } = require_errors(), { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes, { kEmptyObject, once } = require_util(), { validateAbortSignal, validateFunction, validateObject, validateBoolean } = require_validators(), { Promise: Promise2, PromisePrototypeThen, SymbolDispose } = require_primordials(), { isClosed, isReadable, isReadableNodeStream, isReadableStream, isReadableFinished, isReadableErrored, isWritable, isWritableNodeStream, isWritableStream, isWritableFinished, isWritableErrored, isNodeStream, willEmitClose: _willEmitClose, kIsClosedPromise } = require_utils(), addAbortListener;
     function isRequest(stream) {
       return stream.setHeader && typeof stream.abort === "function";
@@ -3265,7 +3260,7 @@ var require_stream = __commonJS(function(exports, module) {
         return eosWeb(stream, options, callback);
       if (!isNodeStream(stream))
         throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream);
-      let readable = (_options$readable = options.readable) !== null && _options$readable !== undefined ? _options$readable : isReadableNodeStream(stream), writable = (_options$writable = options.writable) !== null && _options$writable !== undefined ? _options$writable : isWritableNodeStream(stream), wState = stream._writableState, rState = stream._readableState, onlegacyfinish = () => {
+      let readable = (_options$readable = options.readable) !== null && _options$readable !== undefined ? _options$readable : isReadableNodeStream(stream), writable = (_options$writable = options.writable) !== null && _options$writable !== undefined ? _options$writable : isWritableNodeStream(stream), { _writableState: wState, _readableState: rState } = stream, onlegacyfinish = () => {
         if (!stream.writable)
           onfinish();
       }, willEmitClose = _willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable, writableFinished = isWritableFinished(stream, false), onfinish = () => {
@@ -3394,7 +3389,7 @@ var require_stream = __commonJS(function(exports, module) {
     module2.exports = eos;
     module2.exports.finished = finished;
   });
-  var require_destroy = __commonJS2((exports2, module2) => {
+  var require_destroy = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { aggregateTwoErrors, codes: { ERR_MULTIPLE_CALLBACK }, AbortError } = require_errors(), { Symbol: Symbol2 } = require_primordials(), { kIsDestroyed, isDestroyed, isFinished, isServerRequest } = require_utils(), kDestroy = Symbol2("kDestroy"), kConstruct = Symbol2("kConstruct");
     function checkError(err, w, r) {
       if (err) {
@@ -3425,26 +3420,26 @@ var require_stream = __commonJS(function(exports, module) {
     }
     function _destroy(self, err, cb) {
       let called = false;
-      function onDestroy(err2) {
+      function onDestroy(err) {
         if (called)
           return;
         called = true;
         let { _readableState: r, _writableState: w } = self;
-        if (checkError(err2, w, r), w)
+        if (checkError(err, w, r), w)
           w.closed = true;
         if (r)
           r.closed = true;
         if (typeof cb === "function")
-          cb(err2);
-        if (err2)
-          process2.nextTick(emitErrorCloseNT, self, err2);
+          cb(err);
+        if (err)
+          process2.nextTick(emitErrorCloseNT, self, err);
         else
           process2.nextTick(emitCloseNT, self);
       }
       try {
         self._destroy(err || null, onDestroy);
-      } catch (err2) {
-        onDestroy(err2);
+      } catch (err) {
+        onDestroy(err);
       }
     }
     function emitErrorCloseNT(self, err) {
@@ -3569,7 +3564,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { construct, destroyer, destroy, undestroy, errorOrDestroy };
   });
-  var require_legacy = __commonJS2((exports2, module2) => {
+  var require_legacy = __commonJS2(function(exports2, module2) {
     var { ArrayIsArray, ObjectSetPrototypeOf } = require_primordials(), { EventEmitter: EE } = (init_events(), __toCommonJS(exports_events));
     function Stream(opts) {
       EE.call(this, opts);
@@ -3623,7 +3618,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { Stream, prependListener };
   });
-  var require_add_abort_signal = __commonJS2((exports2, module2) => {
+  var require_add_abort_signal = __commonJS2(function(exports2, module2) {
     var { SymbolDispose } = require_primordials(), { AbortError, codes } = require_errors(), { isNodeStream, isWebStream, kControllerErrorFunction } = require_utils(), eos = require_end_of_stream(), { ERR_INVALID_ARG_TYPE } = codes, addAbortListener, validateAbortSignal = (signal, name) => {
       if (typeof signal !== "object" || !("aborted" in signal))
         throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
@@ -3651,7 +3646,7 @@ var require_stream = __commonJS(function(exports, module) {
       return stream;
     };
   });
-  var require_buffer_list = __commonJS2((exports2, module2) => {
+  var require_buffer_list = __commonJS2(function(exports2, module2) {
     var { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array: Uint8Array2 } = require_primordials(), { Buffer: Buffer2 } = (init_buffer(), __toCommonJS(exports_buffer)), { inspect } = require_util();
     module2.exports = class {
       constructor() {
@@ -3762,7 +3757,7 @@ var require_stream = __commonJS(function(exports, module) {
       }
     };
   });
-  var require_state = __commonJS2((exports2, module2) => {
+  var require_state = __commonJS2(function(exports2, module2) {
     var { MathFloor, NumberIsInteger } = require_primordials(), { validateInteger } = require_validators(), { ERR_INVALID_ARG_VALUE } = require_errors().codes, defaultHighWaterMarkBytes = 16384, defaultHighWaterMarkObjectMode = 16;
     function highWaterMarkFrom(options, isDuplex, duplexKey) {
       return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
@@ -3789,7 +3784,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { getHighWaterMark, getDefaultHighWaterMark, setDefaultHighWaterMark };
   });
-  var require_safe_buffer = __commonJS2((exports2, module2) => {
+  var require_safe_buffer = __commonJS2(function(exports2, module2) {
     /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
     var buffer = (init_buffer(), __toCommonJS(exports_buffer)), Buffer2 = buffer.Buffer;
     function copyProps(src, dst) {
@@ -3834,7 +3829,7 @@ var require_stream = __commonJS(function(exports, module) {
       return buffer.SlowBuffer(size);
     };
   });
-  var require_string_decoder = __commonJS2((exports2) => {
+  var require_string_decoder = __commonJS2(function(exports2) {
     var Buffer2 = require_safe_buffer().Buffer, isEncoding = Buffer2.isEncoding || function(encoding) {
       switch (encoding = "" + encoding, encoding && encoding.toLowerCase()) {
         case "hex":
@@ -4044,7 +4039,7 @@ var require_stream = __commonJS(function(exports, module) {
       return buf && buf.length ? this.write(buf) : "";
     }
   });
-  var require_from = __commonJS2((exports2, module2) => {
+  var require_from = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require_primordials(), { Buffer: Buffer2 } = (init_buffer(), __toCommonJS(exports_buffer)), { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require_errors().codes;
     function from(Readable, iterable, opts) {
       let iterator;
@@ -4103,7 +4098,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = from;
   });
-  var require_readable = __commonJS2((exports2, module2) => {
+  var require_readable = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { ArrayPrototypeIndexOf, NumberIsInteger, NumberIsNaN, NumberParseInt, ObjectDefineProperties, ObjectKeys, ObjectSetPrototypeOf, Promise: Promise2, SafeSet, SymbolAsyncDispose, SymbolAsyncIterator, Symbol: Symbol2 } = require_primordials();
     module2.exports = Readable;
     Readable.ReadableState = ReadableState;
@@ -4721,7 +4716,7 @@ var require_stream = __commonJS(function(exports, module) {
       } }).wrap(src);
     };
   });
-  var require_writable = __commonJS2((exports2, module2) => {
+  var require_writable = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { ArrayPrototypeSlice, Error: Error2, FunctionPrototypeSymbolHasInstance, ObjectDefineProperty, ObjectDefineProperties, ObjectSetPrototypeOf, StringPrototypeToLowerCase, Symbol: Symbol2, SymbolHasInstance } = require_primordials();
     module2.exports = Writable;
     Writable.WritableState = WritableState;
@@ -5020,11 +5015,11 @@ var require_stream = __commonJS(function(exports, module) {
       if (needFinish(state)) {
         if (prefinish(stream, state), state.pendingcb === 0) {
           if (sync)
-            state.pendingcb++, process2.nextTick((stream2, state2) => {
-              if (needFinish(state2))
-                finish(stream2, state2);
+            state.pendingcb++, process2.nextTick((stream, state) => {
+              if (needFinish(state))
+                finish(stream, state);
               else
-                state2.pendingcb--;
+                state.pendingcb--;
             }, stream, state);
           else if (needFinish(state))
             state.pendingcb++, finish(stream, state);
@@ -5106,7 +5101,7 @@ var require_stream = __commonJS(function(exports, module) {
       return lazyWebStreams().newWritableStreamFromStreamWritable(streamWritable);
     };
   });
-  var require_duplexify = __commonJS2((exports2, module2) => {
+  var require_duplexify = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), bufferModule = (init_buffer(), __toCommonJS(exports_buffer)), { isReadable, isWritable, isIterable, isNodeStream, isReadableNodeStream, isWritableNodeStream, isDuplexNodeStream, isReadableStream, isWritableStream } = require_utils(), eos = require_end_of_stream(), { AbortError, codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE } } = require_errors(), { destroyer } = require_destroy(), Duplex = require_duplex(), Readable = require_readable(), Writable = require_writable(), { createDeferredPromise } = require_util(), from = require_from(), Blob = globalThis.Blob || bufferModule.Blob, isBlob = typeof Blob < "u" ? function(b) {
       return b instanceof Blob;
     } : function(b) {
@@ -5139,9 +5134,9 @@ var require_stream = __commonJS(function(exports, module) {
         let { value, write, final, destroy } = fromAsyncGen(body);
         if (isIterable(value))
           return from(Duplexify, value, { objectMode: true, write, final, destroy });
-        let then2 = value === null || value === undefined ? undefined : value.then;
-        if (typeof then2 === "function") {
-          let d, promise = FunctionPrototypeCall(then2, value, (val) => {
+        let then = value === null || value === undefined ? undefined : value.then;
+        if (typeof then === "function") {
+          let d, promise = FunctionPrototypeCall(then, value, (val) => {
             if (val != null)
               throw new ERR_INVALID_RETURN_VALUE("nully", "body", val);
           }, (err) => {
@@ -5270,7 +5265,7 @@ var require_stream = __commonJS(function(exports, module) {
       }, d;
     }
   });
-  var require_duplex = __commonJS2((exports2, module2) => {
+  var require_duplex = __commonJS2(function(exports2, module2) {
     var { ObjectDefineProperties, ObjectGetOwnPropertyDescriptor, ObjectKeys, ObjectSetPrototypeOf } = require_primordials();
     module2.exports = Duplex;
     var Readable = require_readable(), Writable = require_writable();
@@ -5322,7 +5317,7 @@ var require_stream = __commonJS(function(exports, module) {
       return duplexify(body, "body");
     };
   });
-  var require_transform = __commonJS2((exports2, module2) => {
+  var require_transform = __commonJS2(function(exports2, module2) {
     var { ObjectSetPrototypeOf, Symbol: Symbol2 } = require_primordials();
     module2.exports = Transform;
     var { ERR_METHOD_NOT_IMPLEMENTED } = require_errors().codes, Duplex = require_duplex(), { getHighWaterMark } = require_state();
@@ -5391,7 +5386,7 @@ var require_stream = __commonJS(function(exports, module) {
       }
     };
   });
-  var require_passthrough = __commonJS2((exports2, module2) => {
+  var require_passthrough = __commonJS2(function(exports2, module2) {
     var { ObjectSetPrototypeOf } = require_primordials();
     module2.exports = PassThrough;
     var Transform = require_transform();
@@ -5406,7 +5401,7 @@ var require_stream = __commonJS(function(exports, module) {
       cb(null, chunk);
     };
   });
-  var require_pipeline = __commonJS2((exports2, module2) => {
+  var require_pipeline = __commonJS2(function(exports2, module2) {
     var process2 = require_process(), { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator, SymbolDispose } = require_primordials(), eos = require_end_of_stream(), { once } = require_util(), destroyImpl = require_destroy(), Duplex = require_duplex(), { aggregateTwoErrors, codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE, ERR_MISSING_ARGS, ERR_STREAM_DESTROYED, ERR_STREAM_PREMATURE_CLOSE }, AbortError } = require_errors(), { validateFunction, validateAbortSignal } = require_validators(), { isIterable, isReadable, isReadableNodeStream, isNodeStream, isTransformStream, isWebStream, isReadableStream, isReadableFinished } = require_utils(), AbortController = globalThis.AbortController || require_abort_controller().AbortController, PassThrough, Readable, addAbortListener;
     function destroyer(stream, reading, writing) {
       let finished = false;
@@ -5486,8 +5481,8 @@ var require_stream = __commonJS(function(exports, module) {
       } catch (err) {
         try {
           await writer.abort(err), finish(err);
-        } catch (err2) {
-          finish(err2);
+        } catch (err) {
+          finish(err);
         }
       }
     }
@@ -5646,7 +5641,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { pipelineImpl, pipeline };
   });
-  var require_compose = __commonJS2((exports2, module2) => {
+  var require_compose = __commonJS2(function(exports2, module2) {
     var { pipeline } = require_pipeline(), Duplex = require_duplex(), { destroyer } = require_destroy(), { isNodeStream, isReadable, isWritable, isWebStream, isTransformStream, isWritableStream, isReadableStream } = require_utils(), { AbortError, codes: { ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS } } = require_errors(), eos = require_end_of_stream();
     module2.exports = function(...streams) {
       if (streams.length === 0)
@@ -5766,7 +5761,7 @@ var require_stream = __commonJS(function(exports, module) {
       }, d;
     };
   });
-  var require_operators = __commonJS2((exports2, module2) => {
+  var require_operators = __commonJS2(function(exports2, module2) {
     var AbortController = globalThis.AbortController || require_abort_controller().AbortController, { codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE }, AbortError } = require_errors(), { validateAbortSignal, validateInteger, validateObject } = require_validators(), kWeakHandler = require_primordials().Symbol("kWeak"), kResistStopPropagation = require_primordials().Symbol("kResistStopPropagation"), { finished } = require_end_of_stream(), staticCompose = require_compose(), { addAbortSignalNoValidate } = require_add_abort_signal(), { isWritable, isNodeStream } = require_utils(), { deprecate } = require_util(), { ArrayPrototypePush, Boolean: Boolean2, MathFloor, Number: Number2, NumberIsNaN, Promise: Promise2, PromiseReject, PromiseResolve, PromisePrototypeThen, Symbol: Symbol2 } = require_primordials(), kEmpty = Symbol2("kEmpty"), kEof = Symbol2("kEof");
     function compose(stream, options) {
       if (options != null)
@@ -5881,9 +5876,7 @@ var require_stream = __commonJS(function(exports, module) {
     async function every(fn, options = undefined) {
       if (typeof fn !== "function")
         throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
-      return !await some.call(this, async (...args) => {
-        return !await fn(...args);
-      }, options);
+      return !await some.call(this, async (...args) => !await fn(...args), options);
     }
     async function find(fn, options) {
       for await (let result of filter.call(this, fn, options))
@@ -5893,8 +5886,8 @@ var require_stream = __commonJS(function(exports, module) {
     async function forEach(fn, options) {
       if (typeof fn !== "function")
         throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
-      async function forEachFn(value, options2) {
-        return await fn(value, options2), kEmpty;
+      async function forEachFn(value, options) {
+        return await fn(value, options), kEmpty;
       }
       for await (let unused of map.call(this, forEachFn, options))
         ;
@@ -5902,8 +5895,8 @@ var require_stream = __commonJS(function(exports, module) {
     function filter(fn, options) {
       if (typeof fn !== "function")
         throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
-      async function filterFn(value, options2) {
-        if (await fn(value, options2))
+      async function filterFn(value, options) {
+        if (await fn(value, options))
           return value;
         return kEmpty;
       }
@@ -6021,7 +6014,7 @@ var require_stream = __commonJS(function(exports, module) {
     module2.exports.streamReturningOperators = { asIndexedPairs: deprecate(asIndexedPairs, "readable.asIndexedPairs will be removed in a future version."), drop, filter, flatMap, map, take, compose };
     module2.exports.promiseReturningOperators = { every, forEach, reduce, toArray, some, find };
   });
-  var require_promises = __commonJS2((exports2, module2) => {
+  var require_promises = __commonJS2(function(exports2, module2) {
     var { ArrayPrototypePop, Promise: Promise2 } = require_primordials(), { isIterable, isNodeStream, isWebStream } = require_utils(), { pipelineImpl: pl } = require_pipeline(), { finished } = require_end_of_stream();
     require_stream2();
     function pipeline(...streams) {
@@ -6041,7 +6034,7 @@ var require_stream = __commonJS(function(exports, module) {
     }
     module2.exports = { finished, pipeline };
   });
-  var require_stream2 = __commonJS2((exports2, module2) => {
+  var require_stream2 = __commonJS2(function(exports2, module2) {
     var { Buffer: Buffer2 } = (init_buffer(), __toCommonJS(exports_buffer)), { ObjectDefineProperty, ObjectKeys, ReflectApply } = require_primordials(), { promisify: { custom: customPromisify } } = require_util(), { streamReturningOperators, promiseReturningOperators } = require_operators(), { codes: { ERR_ILLEGAL_CONSTRUCTOR } } = require_errors(), compose = require_compose(), { setDefaultHighWaterMark, getDefaultHighWaterMark } = require_state(), { pipeline } = require_pipeline(), { destroyer } = require_destroy(), eos = require_end_of_stream(), promises = require_promises(), utils = require_utils(), Stream = module2.exports = require_legacy().Stream;
     Stream.isDestroyed = utils.isDestroyed;
     Stream.isDisturbed = utils.isDisturbed;
@@ -6094,7 +6087,7 @@ var require_stream = __commonJS(function(exports, module) {
       return Buffer2.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
     };
   });
-  var require_ours = __commonJS2((exports2, module2) => {
+  var require_ours = __commonJS2(function(exports2, module2) {
     var Stream = require_stream();
     {
       let CustomStream = require_stream2(), promises = require_promises(), originalDestroy = CustomStream.Readable.destroy;
@@ -6143,10 +6136,12 @@ var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __t
       return cached;
   }
   target = mod != null ? __create2(__getProtoOf2(mod)) : {};
-  let to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames2(mod))
-    if (!__hasOwnProp2.call(to, key))
-      __defProp2(to, key, { get: __accessProp2.bind(mod, key), enumerable: true });
+  let to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp2.call(mod, "default") ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames2(mod))
+      if (!__hasOwnProp2.call(to, key))
+        __defProp2(to, key, { get: __accessProp2.bind(mod, key), enumerable: true });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -6155,7 +6150,7 @@ var init_assert = __esm(() => {
   __create2 = Object.create;
   ({ getPrototypeOf: __getProtoOf2, defineProperty: __defProp2, getOwnPropertyNames: __getOwnPropNames2 } = Object);
   __hasOwnProp2 = Object.prototype.hasOwnProperty;
-  require_shams = __commonJS2((exports, module) => {
+  require_shams = __commonJS2(function(exports, module) {
     module.exports = function() {
       if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function")
         return false;
@@ -6189,60 +6184,60 @@ var init_assert = __esm(() => {
       return true;
     };
   });
-  require_shams2 = __commonJS2((exports, module) => {
+  require_shams2 = __commonJS2(function(exports, module) {
     var hasSymbols = require_shams();
     module.exports = function() {
       return hasSymbols() && !!Symbol.toStringTag;
     };
   });
-  require_es_object_atoms = __commonJS2((exports, module) => {
+  require_es_object_atoms = __commonJS2(function(exports, module) {
     module.exports = Object;
   });
-  require_es_errors = __commonJS2((exports, module) => {
+  require_es_errors = __commonJS2(function(exports, module) {
     module.exports = Error;
   });
-  require_eval = __commonJS2((exports, module) => {
+  require_eval = __commonJS2(function(exports, module) {
     module.exports = EvalError;
   });
-  require_range = __commonJS2((exports, module) => {
+  require_range = __commonJS2(function(exports, module) {
     module.exports = RangeError;
   });
-  require_ref = __commonJS2((exports, module) => {
+  require_ref = __commonJS2(function(exports, module) {
     module.exports = ReferenceError;
   });
-  require_syntax = __commonJS2((exports, module) => {
+  require_syntax = __commonJS2(function(exports, module) {
     module.exports = SyntaxError;
   });
-  require_type = __commonJS2((exports, module) => {
+  require_type = __commonJS2(function(exports, module) {
     module.exports = TypeError;
   });
-  require_uri = __commonJS2((exports, module) => {
+  require_uri = __commonJS2(function(exports, module) {
     module.exports = URIError;
   });
-  require_abs = __commonJS2((exports, module) => {
+  require_abs = __commonJS2(function(exports, module) {
     module.exports = Math.abs;
   });
-  require_floor = __commonJS2((exports, module) => {
+  require_floor = __commonJS2(function(exports, module) {
     module.exports = Math.floor;
   });
-  require_max = __commonJS2((exports, module) => {
+  require_max = __commonJS2(function(exports, module) {
     module.exports = Math.max;
   });
-  require_min = __commonJS2((exports, module) => {
+  require_min = __commonJS2(function(exports, module) {
     module.exports = Math.min;
   });
-  require_pow = __commonJS2((exports, module) => {
+  require_pow = __commonJS2(function(exports, module) {
     module.exports = Math.pow;
   });
-  require_round = __commonJS2((exports, module) => {
+  require_round = __commonJS2(function(exports, module) {
     module.exports = Math.round;
   });
-  require_isNaN = __commonJS2((exports, module) => {
+  require_isNaN = __commonJS2(function(exports, module) {
     module.exports = Number.isNaN || function(a) {
       return a !== a;
     };
   });
-  require_sign = __commonJS2((exports, module) => {
+  require_sign = __commonJS2(function(exports, module) {
     var $isNaN = require_isNaN();
     module.exports = function(number) {
       if ($isNaN(number) || number === 0)
@@ -6250,10 +6245,10 @@ var init_assert = __esm(() => {
       return number < 0 ? -1 : 1;
     };
   });
-  require_gOPD = __commonJS2((exports, module) => {
+  require_gOPD = __commonJS2(function(exports, module) {
     module.exports = Object.getOwnPropertyDescriptor;
   });
-  require_gopd = __commonJS2((exports, module) => {
+  require_gopd = __commonJS2(function(exports, module) {
     var $gOPD = require_gOPD();
     if ($gOPD)
       try {
@@ -6263,7 +6258,7 @@ var init_assert = __esm(() => {
       }
     module.exports = $gOPD;
   });
-  require_es_define_property = __commonJS2((exports, module) => {
+  require_es_define_property = __commonJS2(function(exports, module) {
     var $defineProperty = Object.defineProperty || false;
     if ($defineProperty)
       try {
@@ -6273,7 +6268,7 @@ var init_assert = __esm(() => {
       }
     module.exports = $defineProperty;
   });
-  require_has_symbols = __commonJS2((exports, module) => {
+  require_has_symbols = __commonJS2(function(exports, module) {
     var origSymbol = typeof Symbol < "u" && Symbol, hasSymbolSham = require_shams();
     module.exports = function() {
       if (typeof origSymbol !== "function")
@@ -6287,14 +6282,14 @@ var init_assert = __esm(() => {
       return hasSymbolSham();
     };
   });
-  require_Reflect_getPrototypeOf = __commonJS2((exports, module) => {
+  require_Reflect_getPrototypeOf = __commonJS2(function(exports, module) {
     module.exports = typeof Reflect < "u" && Reflect.getPrototypeOf || null;
   });
-  require_Object_getPrototypeOf = __commonJS2((exports, module) => {
+  require_Object_getPrototypeOf = __commonJS2(function(exports, module) {
     var $Object = require_es_object_atoms();
     module.exports = $Object.getPrototypeOf || null;
   });
-  require_implementation = __commonJS2((exports, module) => {
+  require_implementation = __commonJS2(function(exports, module) {
     var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ", toStr = Object.prototype.toString, max = Math.max, funcType = "[object Function]", concatty = function(a, b) {
       var arr = [];
       for (var i = 0;i < a.length; i += 1)
@@ -6336,24 +6331,24 @@ var init_assert = __esm(() => {
       return bound;
     };
   });
-  require_function_bind = __commonJS2((exports, module) => {
+  require_function_bind = __commonJS2(function(exports, module) {
     var implementation = require_implementation();
     module.exports = Function.prototype.bind || implementation;
   });
-  require_functionCall = __commonJS2((exports, module) => {
+  require_functionCall = __commonJS2(function(exports, module) {
     module.exports = Function.prototype.call;
   });
-  require_functionApply = __commonJS2((exports, module) => {
+  require_functionApply = __commonJS2(function(exports, module) {
     module.exports = Function.prototype.apply;
   });
-  require_reflectApply = __commonJS2((exports, module) => {
+  require_reflectApply = __commonJS2(function(exports, module) {
     module.exports = typeof Reflect < "u" && Reflect && Reflect.apply;
   });
-  require_actualApply = __commonJS2((exports, module) => {
+  require_actualApply = __commonJS2(function(exports, module) {
     var bind = require_function_bind(), $apply = require_functionApply(), $call = require_functionCall(), $reflectApply = require_reflectApply();
     module.exports = $reflectApply || bind.call($call, $apply);
   });
-  require_call_bind_apply_helpers = __commonJS2((exports, module) => {
+  require_call_bind_apply_helpers = __commonJS2(function(exports, module) {
     var bind = require_function_bind(), $TypeError = require_type(), $call = require_functionCall(), $actualApply = require_actualApply();
     module.exports = function(args) {
       if (args.length < 1 || typeof args[0] !== "function")
@@ -6361,7 +6356,7 @@ var init_assert = __esm(() => {
       return $actualApply(bind, $call, args);
     };
   });
-  require_get = __commonJS2((exports, module) => {
+  require_get = __commonJS2(function(exports, module) {
     var callBind = require_call_bind_apply_helpers(), gOPD = require_gopd(), hasProtoAccessor;
     try {
       hasProtoAccessor = [].__proto__ === Array.prototype;
@@ -6374,7 +6369,7 @@ var init_assert = __esm(() => {
       return $getPrototypeOf(value == null ? value : $Object(value));
     } : false;
   });
-  require_get_proto = __commonJS2((exports, module) => {
+  require_get_proto = __commonJS2(function(exports, module) {
     var reflectGetProto = require_Reflect_getPrototypeOf(), originalGetProto = require_Object_getPrototypeOf(), getDunderProto = require_get();
     module.exports = reflectGetProto ? function(O) {
       return reflectGetProto(O);
@@ -6386,11 +6381,11 @@ var init_assert = __esm(() => {
       return getDunderProto(O);
     } : null;
   });
-  require_hasown = __commonJS2((exports, module) => {
+  require_hasown = __commonJS2(function(exports, module) {
     var call = Function.prototype.call, $hasOwn = Object.prototype.hasOwnProperty, bind = require_function_bind();
     module.exports = bind.call(call, $hasOwn);
   });
-  require_get_intrinsic = __commonJS2((exports, module) => {
+  require_get_intrinsic = __commonJS2(function(exports, module) {
     var undefined2, $Object = require_es_object_atoms(), $Error = require_es_errors(), $EvalError = require_eval(), $RangeError = require_range(), $ReferenceError = require_ref(), $SyntaxError = require_syntax(), $TypeError = require_type(), $URIError = require_uri(), abs = require_abs(), floor = require_floor(), max = require_max(), min = require_min(), pow = require_pow(), round = require_round(), sign = require_sign(), $Function = Function, getEvalledConstructor = function(expressionSyntax) {
       try {
         return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
@@ -6414,7 +6409,7 @@ var init_assert = __esm(() => {
       } catch (e) {
         errorProto = getProto(getProto(e)), INTRINSICS["%Error.prototype%"] = errorProto;
       }
-    var errorProto, doEval = function doEval2(name) {
+    var errorProto, doEval = function doEval(name) {
       var value;
       if (name === "%AsyncFunction%")
         value = getEvalledConstructor("async function () {}");
@@ -6423,11 +6418,11 @@ var init_assert = __esm(() => {
       else if (name === "%AsyncGeneratorFunction%")
         value = getEvalledConstructor("async function* () {}");
       else if (name === "%AsyncGenerator%") {
-        var fn = doEval2("%AsyncGeneratorFunction%");
+        var fn = doEval("%AsyncGeneratorFunction%");
         if (fn)
           value = fn.prototype;
       } else if (name === "%AsyncIteratorPrototype%") {
-        var gen = doEval2("%AsyncGenerator%");
+        var gen = doEval("%AsyncGenerator%");
         if (gen && getProto)
           value = getProto(gen.prototype);
       }
@@ -6495,7 +6490,7 @@ var init_assert = __esm(() => {
       return value;
     };
   });
-  require_call_bound = __commonJS2((exports, module) => {
+  require_call_bound = __commonJS2(function(exports, module) {
     var GetIntrinsic = require_get_intrinsic(), callBindBasic = require_call_bind_apply_helpers(), $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
     module.exports = function(name, allowMissing) {
       var intrinsic = GetIntrinsic(name, !!allowMissing);
@@ -6504,7 +6499,7 @@ var init_assert = __esm(() => {
       return intrinsic;
     };
   });
-  require_is_arguments = __commonJS2((exports, module) => {
+  require_is_arguments = __commonJS2(function(exports, module) {
     var hasToStringTag = require_shams2()(), callBound = require_call_bound(), $toString = callBound("Object.prototype.toString"), isStandardArguments = function(value) {
       if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value)
         return false;
@@ -6519,7 +6514,7 @@ var init_assert = __esm(() => {
     isStandardArguments.isLegacyArguments = isLegacyArguments;
     module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
   });
-  require_is_regex = __commonJS2((exports, module) => {
+  require_is_regex = __commonJS2(function(exports, module) {
     var callBound = require_call_bound(), hasToStringTag = require_shams2()(), hasOwn = require_hasown(), gOPD = require_gopd(), fn;
     if (hasToStringTag) {
       if ($exec = callBound("RegExp.prototype.exec"), isRegexMarker = {}, throwRegexMarker = function() {
@@ -6547,7 +6542,7 @@ var init_assert = __esm(() => {
     var $exec, isRegexMarker, throwRegexMarker, badStringifier, $toString, regexClass;
     module.exports = fn;
   });
-  require_safe_regex_test = __commonJS2((exports, module) => {
+  require_safe_regex_test = __commonJS2(function(exports, module) {
     var callBound = require_call_bound(), isRegex = require_is_regex(), $exec = callBound("RegExp.prototype.exec"), $TypeError = require_type();
     module.exports = function(regex) {
       if (!isRegex(regex))
@@ -6557,11 +6552,11 @@ var init_assert = __esm(() => {
       };
     };
   });
-  require_generator_function = __commonJS2((exports, module) => {
+  require_generator_function = __commonJS2(function(exports, module) {
     var cached = function* () {}.constructor;
     module.exports = () => cached;
   });
-  require_is_generator_function = __commonJS2((exports, module) => {
+  require_is_generator_function = __commonJS2(function(exports, module) {
     var callBound = require_call_bound(), safeRegexTest = require_safe_regex_test(), isFnRegex = safeRegexTest(/^\s*(?:function)?\*/), hasToStringTag = require_shams2()(), getProto = require_get_proto(), toStr = callBound("Object.prototype.toString"), fnToStr = callBound("Function.prototype.toString"), getGeneratorFunction = require_generator_function();
     module.exports = function(fn) {
       if (typeof fn !== "function")
@@ -6578,7 +6573,7 @@ var init_assert = __esm(() => {
       return GeneratorFunction && getProto(fn) === GeneratorFunction.prototype;
     };
   });
-  require_is_callable = __commonJS2((exports, module) => {
+  require_is_callable = __commonJS2(function(exports, module) {
     var fnToStr = Function.prototype.toString, reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply, badArrayLike, isCallableMarker;
     if (typeof reflectApply === "function" && typeof Object.defineProperty === "function")
       try {
@@ -6654,7 +6649,7 @@ var init_assert = __esm(() => {
       return tryFunctionObject(value);
     };
   });
-  require_for_each = __commonJS2((exports, module) => {
+  require_for_each = __commonJS2(function(exports, module) {
     var isCallable = require_is_callable(), toStr = Object.prototype.toString, hasOwnProperty = Object.prototype.hasOwnProperty, forEachArray = function(array, iterator, receiver) {
       for (var i = 0, len = array.length;i < len; i++)
         if (hasOwnProperty.call(array, i))
@@ -6693,10 +6688,10 @@ var init_assert = __esm(() => {
         forEachObject(list, iterator, receiver);
     };
   });
-  require_possible_typed_array_names = __commonJS2((exports, module) => {
+  require_possible_typed_array_names = __commonJS2(function(exports, module) {
     module.exports = ["Float16Array", "Float32Array", "Float64Array", "Int8Array", "Int16Array", "Int32Array", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigInt64Array", "BigUint64Array"];
   });
-  require_available_typed_arrays = __commonJS2((exports, module) => {
+  require_available_typed_arrays = __commonJS2(function(exports, module) {
     var possibleNames = require_possible_typed_array_names(), g = typeof globalThis > "u" ? globalThis : globalThis;
     module.exports = function() {
       var out = [];
@@ -6706,7 +6701,7 @@ var init_assert = __esm(() => {
       return out;
     };
   });
-  require_define_data_property = __commonJS2((exports, module) => {
+  require_define_data_property = __commonJS2(function(exports, module) {
     var $defineProperty = require_es_define_property(), $SyntaxError = require_syntax(), $TypeError = require_type(), gopd = require_gopd();
     module.exports = function(obj, property, value) {
       if (!obj || typeof obj !== "object" && typeof obj !== "function")
@@ -6730,7 +6725,7 @@ var init_assert = __esm(() => {
         throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
     };
   });
-  require_has_property_descriptors = __commonJS2((exports, module) => {
+  require_has_property_descriptors = __commonJS2(function(exports, module) {
     var $defineProperty = require_es_define_property(), hasPropertyDescriptors = function() {
       return !!$defineProperty;
     };
@@ -6745,7 +6740,7 @@ var init_assert = __esm(() => {
     };
     module.exports = hasPropertyDescriptors;
   });
-  require_set_function_length = __commonJS2((exports, module) => {
+  require_set_function_length = __commonJS2(function(exports, module) {
     var GetIntrinsic = require_get_intrinsic(), define = require_define_data_property(), hasDescriptors = require_has_property_descriptors()(), gOPD = require_gopd(), $TypeError = require_type(), $floor = GetIntrinsic("%Math.floor%");
     module.exports = function(fn, length) {
       if (typeof fn !== "function")
@@ -6768,13 +6763,13 @@ var init_assert = __esm(() => {
       return fn;
     };
   });
-  require_applyBind = __commonJS2((exports, module) => {
+  require_applyBind = __commonJS2(function(exports, module) {
     var bind = require_function_bind(), $apply = require_functionApply(), actualApply = require_actualApply();
     module.exports = function() {
       return actualApply(bind, $apply, arguments);
     };
   });
-  require_call_bind = __commonJS2((exports, module) => {
+  require_call_bind = __commonJS2(function(exports, module) {
     var setFunctionLength = require_set_function_length(), $defineProperty = require_es_define_property(), callBindBasic = require_call_bind_apply_helpers(), applyBind = require_applyBind();
     module.exports = function(originalFunction) {
       var func = callBindBasic(arguments), adjustedLength = originalFunction.length - (arguments.length - 1);
@@ -6785,7 +6780,7 @@ var init_assert = __esm(() => {
     else
       module.exports.apply = applyBind;
   });
-  require_which_typed_array = __commonJS2((exports, module) => {
+  require_which_typed_array = __commonJS2(function(exports, module) {
     var forEach = require_for_each(), availableTypedArrays = require_available_typed_arrays(), callBind = require_call_bind(), callBound = require_call_bound(), gOPD = require_gopd(), getProto = require_get_proto(), $toString = callBound("Object.prototype.toString"), hasToStringTag = require_shams2()(), g = typeof globalThis > "u" ? globalThis : globalThis, typedArrays = availableTypedArrays(), $slice = callBound("String.prototype.slice"), $indexOf = callBound("Array.prototype.indexOf", true) || function(array, value) {
       for (var i = 0;i < array.length; i += 1)
         if (array[i] === value)
@@ -6844,13 +6839,13 @@ var init_assert = __esm(() => {
       return tryTypedArrays(value);
     };
   });
-  require_is_typed_array = __commonJS2((exports, module) => {
+  require_is_typed_array = __commonJS2(function(exports, module) {
     var whichTypedArray = require_which_typed_array();
     module.exports = function(value) {
       return !!whichTypedArray(value);
     };
   });
-  require_types = __commonJS2((exports) => {
+  require_types = __commonJS2(function(exports) {
     var isArgumentsObject = require_is_arguments(), isGeneratorFunction = require_is_generator_function(), whichTypedArray = require_which_typed_array(), isTypedArray = require_is_typed_array();
     function uncurryThis(f) {
       return f.call.bind(f);
@@ -7052,12 +7047,12 @@ var init_assert = __esm(() => {
       } });
     });
   });
-  require_isBuffer = __commonJS2((exports, module) => {
+  require_isBuffer = __commonJS2(function(exports, module) {
     module.exports = function(arg) {
       return arg instanceof Buffer;
     };
   });
-  require_inherits_browser = __commonJS2((exports, module) => {
+  require_inherits_browser = __commonJS2(function(exports, module) {
     if (typeof Object.create === "function")
       module.exports = function(ctor, superCtor) {
         if (superCtor)
@@ -7072,7 +7067,7 @@ var init_assert = __esm(() => {
         }
       };
   });
-  require_inherits = __commonJS2((exports, module) => {
+  require_inherits = __commonJS2(function(exports, module) {
     try {
       if (util = (init_util(), __toCommonJS(exports_util)), typeof util.inherits !== "function")
         throw "";
@@ -7082,7 +7077,7 @@ var init_assert = __esm(() => {
     }
     var util;
   });
-  require_util = __commonJS2((exports) => {
+  require_util = __commonJS2(function(exports) {
     var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function(obj) {
       var keys = Object.keys(obj), descriptors = {};
       for (var i = 0;i < keys.length; i++)
@@ -7096,12 +7091,12 @@ var init_assert = __esm(() => {
           objects.push(inspect(arguments[i]));
         return objects.join(" ");
       }
-      var i = 1, args = arguments, len = args.length, str = String(f).replace(formatRegExp, function(x2) {
-        if (x2 === "%%")
+      var i = 1, args = arguments, len = args.length, str = String(f).replace(formatRegExp, function(x) {
+        if (x === "%%")
           return "%";
         if (i >= len)
-          return x2;
-        switch (x2) {
+          return x;
+        switch (x) {
           case "%s":
             return String(args[i++]);
           case "%d":
@@ -7113,7 +7108,7 @@ var init_assert = __esm(() => {
               return "[Circular]";
             }
           default:
-            return x2;
+            return x;
         }
       });
       for (var x = args[i];i < len; x = args[++i])
@@ -7493,12 +7488,12 @@ var init_assert = __esm(() => {
     }
     exports.callbackify = callbackify;
   });
-  require_errors = __commonJS2((exports, module) => {
+  require_errors = __commonJS2(function(exports, module) {
     function _typeof(o) {
-      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && typeof Symbol == "function" && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+        return typeof o;
+      } : function(o) {
+        return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
       }, _typeof(o);
     }
     function _defineProperties(target, props) {
@@ -7543,8 +7538,8 @@ var init_assert = __esm(() => {
         _setPrototypeOf(subClass, superClass);
     }
     function _setPrototypeOf(o, p) {
-      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o2, p2) {
-        return o2.__proto__ = p2, o2;
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
+        return o.__proto__ = p, o;
       }, _setPrototypeOf(o, p);
     }
     function _createSuper(Derived) {
@@ -7585,8 +7580,8 @@ var init_assert = __esm(() => {
       }
     }
     function _getPrototypeOf(o) {
-      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o2) {
-        return o2.__proto__ || Object.getPrototypeOf(o2);
+      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
       }, _getPrototypeOf(o);
     }
     var codes = {}, assert, util;
@@ -7600,13 +7595,13 @@ var init_assert = __esm(() => {
           return message(arg1, arg2, arg3);
       }
       var NodeError = function(_Base) {
-        _inherits(NodeError2, _Base);
-        var _super = _createSuper(NodeError2);
-        function NodeError2(arg1, arg2, arg3) {
+        _inherits(NodeError, _Base);
+        var _super = _createSuper(NodeError);
+        function NodeError(arg1, arg2, arg3) {
           var _this;
-          return _classCallCheck(this, NodeError2), _this = _super.call(this, getMessage(arg1, arg2, arg3)), _this.code = code, _this;
+          return _classCallCheck(this, NodeError), _this = _super.call(this, getMessage(arg1, arg2, arg3)), _this.code = code, _this;
         }
-        return _createClass(NodeError2);
+        return _createClass(NodeError);
       }(Base);
       codes[code] = NodeError;
     }
@@ -7700,13 +7695,13 @@ var init_assert = __esm(() => {
     }, TypeError);
     exports.codes = codes;
   });
-  require_assertion_error = __commonJS2((exports, module) => {
+  require_assertion_error = __commonJS2(function(exports, module) {
     function ownKeys(e, r) {
       var t = Object.keys(e);
       if (Object.getOwnPropertySymbols) {
         var o = Object.getOwnPropertySymbols(e);
-        r && (o = o.filter(function(r2) {
-          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+        r && (o = o.filter(function(r) {
+          return Object.getOwnPropertyDescriptor(e, r).enumerable;
         })), t.push.apply(t, o);
       }
       return t;
@@ -7714,10 +7709,10 @@ var init_assert = __esm(() => {
     function _objectSpread(e) {
       for (var r = 1;r < arguments.length; r++) {
         var t = arguments[r] != null ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
-          _defineProperty(e, r2, t[r2]);
-        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
-          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+        r % 2 ? ownKeys(Object(t), true).forEach(function(r) {
+          _defineProperty(e, r, t[r]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+          Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
         });
       }
       return e;
@@ -7796,32 +7791,32 @@ var init_assert = __esm(() => {
     }
     function _wrapNativeSuper(Class) {
       var _cache = typeof Map === "function" ? new Map : undefined;
-      return _wrapNativeSuper = function(Class2) {
-        if (Class2 === null || !_isNativeFunction(Class2))
-          return Class2;
-        if (typeof Class2 !== "function")
+      return _wrapNativeSuper = function(Class) {
+        if (Class === null || !_isNativeFunction(Class))
+          return Class;
+        if (typeof Class !== "function")
           throw TypeError("Super expression must either be null or a function");
         if (typeof _cache < "u") {
-          if (_cache.has(Class2))
-            return _cache.get(Class2);
-          _cache.set(Class2, Wrapper);
+          if (_cache.has(Class))
+            return _cache.get(Class);
+          _cache.set(Class, Wrapper);
         }
         function Wrapper() {
-          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+          return _construct(Class, arguments, _getPrototypeOf(this).constructor);
         }
-        return Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }), _setPrototypeOf(Wrapper, Class2);
+        return Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }), _setPrototypeOf(Wrapper, Class);
       }, _wrapNativeSuper(Class);
     }
     function _construct(Parent, args, Class) {
       if (_isNativeReflectConstruct())
         _construct = Reflect.construct.bind();
       else
-        _construct = function(Parent2, args2, Class2) {
+        _construct = function(Parent, args, Class) {
           var a = [null];
-          a.push.apply(a, args2);
-          var Constructor = Function.bind.apply(Parent2, a), instance = new Constructor;
-          if (Class2)
-            _setPrototypeOf(instance, Class2.prototype);
+          a.push.apply(a, args);
+          var Constructor = Function.bind.apply(Parent, a), instance = new Constructor;
+          if (Class)
+            _setPrototypeOf(instance, Class.prototype);
           return instance;
         };
       return _construct.apply(null, arguments);
@@ -7843,20 +7838,20 @@ var init_assert = __esm(() => {
       return Function.toString.call(fn).indexOf("[native code]") !== -1;
     }
     function _setPrototypeOf(o, p) {
-      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o2, p2) {
-        return o2.__proto__ = p2, o2;
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
+        return o.__proto__ = p, o;
       }, _setPrototypeOf(o, p);
     }
     function _getPrototypeOf(o) {
-      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o2) {
-        return o2.__proto__ || Object.getPrototypeOf(o2);
+      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
       }, _getPrototypeOf(o);
     }
     function _typeof(o) {
-      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && typeof Symbol == "function" && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+        return typeof o;
+      } : function(o) {
+        return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
       }, _typeof(o);
     }
     var _require = require_util(), inspect = _require.inspect, _require2 = require_errors(), ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
@@ -8078,7 +8073,7 @@ should equal
     }(_wrapNativeSuper(Error), inspect.custom);
     module.exports = AssertionError2;
   });
-  require_isArguments = __commonJS2((exports, module) => {
+  require_isArguments = __commonJS2(function(exports, module) {
     var toStr = Object.prototype.toString;
     module.exports = function(value) {
       var str = toStr.call(value), isArgs = str === "[object Arguments]";
@@ -8087,7 +8082,7 @@ should equal
       return isArgs;
     };
   });
-  require_implementation2 = __commonJS2((exports, module) => {
+  require_implementation2 = __commonJS2(function(exports, module) {
     var keysShim;
     if (!Object.keys)
       has = Object.prototype.hasOwnProperty, toStr = Object.prototype.toString, isArgs = require_isArguments(), isEnumerable = Object.prototype.propertyIsEnumerable, hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString"), hasProtoEnumBug = isEnumerable.call(function() {}, "prototype"), dontEnums = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"], equalsConstructorPrototype = function(o) {
@@ -8142,7 +8137,7 @@ should equal
     var has, toStr, isArgs, isEnumerable, hasDontEnumBug, hasProtoEnumBug, dontEnums, equalsConstructorPrototype, excludedKeys, hasAutomationEqualityBug, equalsConstructorPrototypeIfNotBuggy;
     module.exports = keysShim;
   });
-  require_object_keys = __commonJS2((exports, module) => {
+  require_object_keys = __commonJS2(function(exports, module) {
     var slice = Array.prototype.slice, isArgs = require_isArguments(), origKeys = Object.keys, keysShim = origKeys ? function(o) {
       return origKeys(o);
     } : require_implementation2(), originalKeys = Object.keys;
@@ -8164,7 +8159,7 @@ should equal
     };
     module.exports = keysShim;
   });
-  require_implementation3 = __commonJS2((exports, module) => {
+  require_implementation3 = __commonJS2(function(exports, module) {
     var objectKeys = require_object_keys(), hasSymbols = require_shams()(), callBound = require_call_bound(), $Object = require_es_object_atoms(), $push = callBound("Array.prototype.push"), $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable"), originalGetSymbols = hasSymbols ? $Object.getOwnPropertySymbols : null;
     module.exports = function(target, source1) {
       if (target == null)
@@ -8193,7 +8188,7 @@ should equal
       return to;
     };
   });
-  require_polyfill = __commonJS2((exports, module) => {
+  require_polyfill = __commonJS2(function(exports, module) {
     var implementation = require_implementation3(), lacksProperEnumerationOrder = function() {
       if (!Object.assign)
         return false;
@@ -8225,7 +8220,7 @@ should equal
       return Object.assign;
     };
   });
-  require_implementation4 = __commonJS2((exports, module) => {
+  require_implementation4 = __commonJS2(function(exports, module) {
     var numberIsNaN = function(value) {
       return value !== value;
     };
@@ -8239,13 +8234,13 @@ should equal
       return false;
     };
   });
-  require_polyfill2 = __commonJS2((exports, module) => {
+  require_polyfill2 = __commonJS2(function(exports, module) {
     var implementation = require_implementation4();
     module.exports = function() {
       return typeof Object.is === "function" ? Object.is : implementation;
     };
   });
-  require_callBound = __commonJS2((exports, module) => {
+  require_callBound = __commonJS2(function(exports, module) {
     var GetIntrinsic = require_get_intrinsic(), callBind = require_call_bind(), $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
     module.exports = function(name, allowMissing) {
       var intrinsic = GetIntrinsic(name, !!allowMissing);
@@ -8254,7 +8249,7 @@ should equal
       return intrinsic;
     };
   });
-  require_define_properties = __commonJS2((exports, module) => {
+  require_define_properties = __commonJS2(function(exports, module) {
     var keys = require_object_keys(), hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol", toStr = Object.prototype.toString, concat = Array.prototype.concat, defineDataProperty = require_define_data_property(), isFunction = function(fn) {
       return typeof fn === "function" && toStr.call(fn) === "[object Function]";
     }, supportsDescriptors = require_has_property_descriptors()(), defineProperty = function(object, name, value, predicate) {
@@ -8279,7 +8274,7 @@ should equal
     defineProperties.supportsDescriptors = !!supportsDescriptors;
     module.exports = defineProperties;
   });
-  require_shim = __commonJS2((exports, module) => {
+  require_shim = __commonJS2(function(exports, module) {
     var getPolyfill = require_polyfill2(), define = require_define_properties();
     module.exports = function() {
       var polyfill = getPolyfill();
@@ -8288,17 +8283,17 @@ should equal
       } }), polyfill;
     };
   });
-  require_object_is = __commonJS2((exports, module) => {
+  require_object_is = __commonJS2(function(exports, module) {
     var define = require_define_properties(), callBind = require_call_bind(), implementation = require_implementation4(), getPolyfill = require_polyfill2(), shim = require_shim(), polyfill = callBind(getPolyfill(), Object);
     define(polyfill, { getPolyfill, implementation, shim });
     module.exports = polyfill;
   });
-  require_implementation5 = __commonJS2((exports, module) => {
+  require_implementation5 = __commonJS2(function(exports, module) {
     module.exports = function(value) {
       return value !== value;
     };
   });
-  require_polyfill3 = __commonJS2((exports, module) => {
+  require_polyfill3 = __commonJS2(function(exports, module) {
     var implementation = require_implementation5();
     module.exports = function() {
       if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a"))
@@ -8306,7 +8301,7 @@ should equal
       return implementation;
     };
   });
-  require_shim2 = __commonJS2((exports, module) => {
+  require_shim2 = __commonJS2(function(exports, module) {
     var define = require_define_properties(), getPolyfill = require_polyfill3();
     module.exports = function() {
       var polyfill = getPolyfill();
@@ -8315,12 +8310,12 @@ should equal
       } }), polyfill;
     };
   });
-  require_is_nan = __commonJS2((exports, module) => {
+  require_is_nan = __commonJS2(function(exports, module) {
     var callBind = require_call_bind(), define = require_define_properties(), implementation = require_implementation5(), getPolyfill = require_polyfill3(), shim = require_shim2(), polyfill = callBind(getPolyfill(), Number);
     define(polyfill, { getPolyfill, implementation, shim });
     module.exports = polyfill;
   });
-  require_comparisons = __commonJS2((exports, module) => {
+  require_comparisons = __commonJS2(function(exports, module) {
     function _slicedToArray(arr, i) {
       return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
     }
@@ -8360,8 +8355,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           } else
             for (;!(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true)
               ;
-        } catch (r2) {
-          o = true, n = r2;
+        } catch (r) {
+          o = true, n = r;
         } finally {
           try {
             if (!f && t.return != null && (u = t.return(), Object(u) !== u))
@@ -8379,10 +8374,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         return arr;
     }
     function _typeof(o) {
-      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && typeof Symbol == "function" && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+        return typeof o;
+      } : function(o) {
+        return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
       }, _typeof(o);
     }
     var regexFlagsSupported = /a/g.flags !== undefined, arrayFromSet = function(set) {
@@ -8750,12 +8745,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     }
     module.exports = { isDeepEqual, isDeepStrictEqual };
   });
-  require_assert = __commonJS2((exports, module) => {
+  require_assert = __commonJS2(function(exports, module) {
     function _typeof(o) {
-      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && typeof Symbol == "function" && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+        return typeof o;
+      } : function(o) {
+        return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
       }, _typeof(o);
     }
     function _defineProperties(target, props) {
@@ -8905,9 +8900,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       if (objectIs(actual, expected))
         innerFail({ actual, expected, message, operator: "notStrictEqual", stackStartFn: notStrictEqual2 });
     };
-    var Comparison = _createClass(function Comparison2(obj, keys, actual) {
+    var Comparison = _createClass(function Comparison(obj, keys, actual) {
       var _this = this;
-      _classCallCheck(this, Comparison2), keys.forEach(function(key) {
+      _classCallCheck(this, Comparison), keys.forEach(function(key) {
         if (key in obj)
           if (actual !== undefined && typeof actual[key] === "string" && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key]))
             _this[key] = actual[key];
@@ -9106,7 +9101,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     assert.strict = objectAssign(strict2, assert, { equal: assert.strictEqual, deepEqual: assert.deepStrictEqual, notEqual: assert.notStrictEqual, notDeepEqual: assert.notDeepStrictEqual });
     assert.strict.strict = assert.strict;
   });
-  assert = __toESM2(require_assert(), 1);
+  assert = __toESM2(require_assert());
   ({ AssertionError, CallTracker, deepEqual, deepStrictEqual, doesNotMatch, doesNotReject, doesNotThrow, equal, fail, ifError, match, notDeepEqual, notDeepStrictEqual, notEqual, notStrictEqual, ok, rejects, strict, strictEqual, throws } = assert);
   assert_default = assert;
 });
@@ -9119,7 +9114,7 @@ function __exportSetter2(name, newValue) {
   this[name] = __returnValue2.bind(null, newValue);
 }
 var __create3, __getProtoOf3, __defProp3, __getOwnPropNames3, __hasOwnProp3, __reExport = (target, mod, secondTarget) => {
-  var keys = __getOwnPropNames3(mod);
+  var keys = mod && typeof mod === "object" || typeof mod === "function" ? __getOwnPropNames3(mod) : [];
   for (let key of keys)
     if (!__hasOwnProp3.call(target, key) && key !== "default")
       __defProp3(target, key, { get: __accessProp3.bind(mod, key), enumerable: true });
@@ -9137,10 +9132,12 @@ var __create3, __getProtoOf3, __defProp3, __getOwnPropNames3, __hasOwnProp3, __r
       return cached;
   }
   target = mod != null ? __create3(__getProtoOf3(mod)) : {};
-  let to = isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames3(mod))
-    if (!__hasOwnProp3.call(to, key))
-      __defProp3(to, key, { get: __accessProp3.bind(mod, key), enumerable: true });
+  let to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp3.call(mod, "default") ? __defProp3(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames3(mod))
+      if (!__hasOwnProp3.call(to, key))
+        __defProp3(to, key, { get: __accessProp3.bind(mod, key), enumerable: true });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -9152,13 +9149,13 @@ var init_zlib = __esm(() => {
   __create3 = Object.create;
   ({ getPrototypeOf: __getProtoOf3, defineProperty: __defProp3, getOwnPropertyNames: __getOwnPropNames3 } = Object);
   __hasOwnProp3 = Object.prototype.hasOwnProperty;
-  require_zstream = __commonJS3((exports, module) => {
+  require_zstream = __commonJS3(function(exports, module) {
     function ZStream() {
       this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0;
     }
     module.exports = ZStream;
   });
-  require_common = __commonJS3((exports) => {
+  require_common = __commonJS3(function(exports) {
     var TYPED_OK = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Int32Array < "u";
     function _has(obj, key) {
       return Object.prototype.hasOwnProperty.call(obj, key);
@@ -9214,7 +9211,7 @@ var init_zlib = __esm(() => {
     };
     exports.setTyped(TYPED_OK);
   });
-  require_trees = __commonJS3((exports) => {
+  require_trees = __commonJS3(function(exports) {
     var utils = require_common(), Z_FIXED = 4, Z_BINARY = 0, Z_TEXT = 1, Z_UNKNOWN = 2;
     function zero(buf) {
       var len = buf.length;
@@ -9544,7 +9541,7 @@ var init_zlib = __esm(() => {
     exports._tr_tally = _tr_tally;
     exports._tr_align = _tr_align;
   });
-  require_adler32 = __commonJS3((exports, module) => {
+  require_adler32 = __commonJS3(function(exports, module) {
     function adler32(adler, buf, len, pos) {
       var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
       while (len !== 0) {
@@ -9558,7 +9555,7 @@ var init_zlib = __esm(() => {
     }
     module.exports = adler32;
   });
-  require_crc32 = __commonJS3((exports, module) => {
+  require_crc32 = __commonJS3(function(exports, module) {
     function makeTable() {
       var c, table = [];
       for (var n = 0;n < 256; n++) {
@@ -9579,10 +9576,10 @@ var init_zlib = __esm(() => {
     }
     module.exports = crc32;
   });
-  require_messages = __commonJS3((exports, module) => {
+  require_messages = __commonJS3(function(exports, module) {
     module.exports = { 2: "need dictionary", 1: "stream end", 0: "", "-1": "file error", "-2": "stream error", "-3": "data error", "-4": "insufficient memory", "-5": "buffer error", "-6": "incompatible version" };
   });
-  require_deflate = __commonJS3((exports) => {
+  require_deflate = __commonJS3(function(exports) {
     var utils = require_common(), trees = require_trees(), adler32 = require_adler32(), crc32 = require_crc32(), msg = require_messages(), Z_NO_FLUSH = 0, Z_PARTIAL_FLUSH = 1, Z_FULL_FLUSH = 3, Z_FINISH = 4, Z_BLOCK = 5, Z_OK = 0, Z_STREAM_END = 1, Z_STREAM_ERROR = -2, Z_DATA_ERROR = -3, Z_BUF_ERROR = -5, Z_DEFAULT_COMPRESSION = -1, Z_FILTERED = 1, Z_HUFFMAN_ONLY = 2, Z_RLE = 3, Z_FIXED = 4, Z_DEFAULT_STRATEGY = 0, Z_UNKNOWN = 2, Z_DEFLATED = 8, MAX_MEM_LEVEL = 9, MAX_WBITS = 15, DEF_MEM_LEVEL = 8, LENGTH_CODES = 29, LITERALS = 256, L_CODES = LITERALS + 1 + LENGTH_CODES, D_CODES = 30, BL_CODES = 19, HEAP_SIZE = 2 * L_CODES + 1, MAX_BITS = 15, MIN_MATCH = 3, MAX_MATCH = 258, MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1, PRESET_DICT = 32, INIT_STATE = 42, EXTRA_STATE = 69, NAME_STATE = 73, COMMENT_STATE = 91, HCRC_STATE = 103, BUSY_STATE = 113, FINISH_STATE = 666, BS_NEED_MORE = 1, BS_BLOCK_DONE = 2, BS_FINISH_STARTED = 3, BS_FINISH_DONE = 4, OS_CODE = 3;
     function err(strm, errorCode) {
       return strm.msg = msg[errorCode], errorCode;
@@ -10097,7 +10094,7 @@ var init_zlib = __esm(() => {
     exports.deflateSetDictionary = deflateSetDictionary;
     exports.deflateInfo = "pako deflate (from Nodeca project)";
   });
-  require_inffast = __commonJS3((exports, module) => {
+  require_inffast = __commonJS3(function(exports, module) {
     var BAD = 30, TYPE = 12;
     module.exports = function(strm, start) {
       var state, _in, last, _out, beg, end, dmax, wsize, whave, wnext, s_window, hold, bits, lcode, dcode, lmask, dmask, here, op, len, dist, from, from_source, input, output;
@@ -10209,7 +10206,7 @@ var init_zlib = __esm(() => {
       return;
     };
   });
-  require_inftrees = __commonJS3((exports, module) => {
+  require_inftrees = __commonJS3(function(exports, module) {
     var utils = require_common(), MAXBITS = 15, ENOUGH_LENS = 852, ENOUGH_DISTS = 592, CODES = 0, LENS = 1, DISTS = 2, lbase = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0], lext = [16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78], dbase = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0], dext = [16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64];
     module.exports = function(type, lens, lens_index, codes, table, table_index, work, opts) {
       var bits = opts.bits, len = 0, sym = 0, min = 0, max = 0, root = 0, curr = 0, drop = 0, left = 0, used = 0, huff = 0, incr, fill, low, mask, next, base = null, base_index = 0, end, count = new utils.Buf16(MAXBITS + 1), offs = new utils.Buf16(MAXBITS + 1), extra = null, extra_index = 0, here_bits, here_op, here_val;
@@ -10292,7 +10289,7 @@ var init_zlib = __esm(() => {
       return opts.bits = root, 0;
     };
   });
-  require_inflate = __commonJS3((exports) => {
+  require_inflate = __commonJS3(function(exports) {
     var utils = require_common(), adler32 = require_adler32(), crc32 = require_crc32(), inflate_fast = require_inffast(), inflate_table = require_inftrees(), CODES = 0, LENS = 1, DISTS = 2, Z_FINISH = 4, Z_BLOCK = 5, Z_TREES = 6, Z_OK = 0, Z_STREAM_END = 1, Z_NEED_DICT = 2, Z_STREAM_ERROR = -2, Z_DATA_ERROR = -3, Z_MEM_ERROR = -4, Z_BUF_ERROR = -5, Z_DEFLATED = 8, HEAD = 1, FLAGS = 2, TIME = 3, OS = 4, EXLEN = 5, EXTRA = 6, NAME = 7, COMMENT = 8, HCRC = 9, DICTID = 10, DICT = 11, TYPE = 12, TYPEDO = 13, STORED = 14, COPY_ = 15, COPY = 16, TABLE = 17, LENLENS = 18, CODELENS = 19, LEN_ = 20, LEN = 21, LENEXT = 22, DIST = 23, DISTEXT = 24, MATCH = 25, LIT = 26, CHECK = 27, LENGTH = 28, DONE = 29, BAD = 30, MEM = 31, SYNC = 32, ENOUGH_LENS = 852, ENOUGH_DISTS = 592, MAX_WBITS = 15, DEF_WBITS = MAX_WBITS;
     function zswap32(q) {
       return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
@@ -10922,10 +10919,10 @@ var init_zlib = __esm(() => {
     exports.inflateSetDictionary = inflateSetDictionary;
     exports.inflateInfo = "pako inflate (from Nodeca project)";
   });
-  require_constants = __commonJS3((exports, module) => {
+  require_constants = __commonJS3(function(exports, module) {
     module.exports = { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BLOCK: 5, Z_TREES: 6, Z_OK: 0, Z_STREAM_END: 1, Z_NEED_DICT: 2, Z_ERRNO: -1, Z_STREAM_ERROR: -2, Z_DATA_ERROR: -3, Z_BUF_ERROR: -5, Z_NO_COMPRESSION: 0, Z_BEST_SPEED: 1, Z_BEST_COMPRESSION: 9, Z_DEFAULT_COMPRESSION: -1, Z_FILTERED: 1, Z_HUFFMAN_ONLY: 2, Z_RLE: 3, Z_FIXED: 4, Z_DEFAULT_STRATEGY: 0, Z_BINARY: 0, Z_TEXT: 1, Z_UNKNOWN: 2, Z_DEFLATED: 8 };
   });
-  require_binding = __commonJS3((exports) => {
+  require_binding = __commonJS3(function(exports) {
     var assert = (init_assert(), __toCommonJS(exports_assert)), Zstream = require_zstream(), zlib_deflate = require_deflate(), zlib_inflate = require_inflate(), constants = require_constants();
     for (key in constants)
       exports[key] = constants[key];
@@ -11131,7 +11128,7 @@ var init_zlib = __esm(() => {
     };
     exports.Zlib = Zlib;
   });
-  require_lib = __commonJS3((exports) => {
+  require_lib = __commonJS3(function(exports) {
     var Buffer2 = (init_buffer(), __toCommonJS(exports_buffer)).Buffer, Transform = require_stream().Transform, binding = require_binding(), util = (init_util(), __toCommonJS(exports_util)), assert = (init_assert(), __toCommonJS(exports_assert)).ok, kMaxLength = (init_buffer(), __toCommonJS(exports_buffer)).kMaxLength, kRangeErrorMessage = "Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + " bytes";
     binding.Z_MIN_WINDOWBITS = 8;
     binding.Z_MAX_WINDOWBITS = 15;
@@ -11475,8 +11472,8 @@ var init_zlib = __esm(() => {
   });
   exports_zlib = {};
   __export2(exports_zlib, { default: () => import_browserify_zlib.default });
-  __reExport(exports_zlib, __toESM3(require_lib(), 1));
-  import_browserify_zlib = __toESM3(require_lib(), 1);
+  __reExport(exports_zlib, __toESM3(require_lib()));
+  import_browserify_zlib = __toESM3(require_lib());
   export_default = import_browserify_zlib.default;
 });
 
@@ -13646,8 +13643,8 @@ function parse(path) {
   var ret = { root: "", dir: "", base: "", ext: "", name: "" };
   if (path.length === 0)
     return ret;
-  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
-  if (isAbsolute2)
+  var code = path.charCodeAt(0), isAbsolute = code === 47, start;
+  if (isAbsolute)
     ret.root = "/", start = 1;
   else
     start = 0;
@@ -13672,12 +13669,12 @@ function parse(path) {
   }
   if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
     if (end !== -1)
-      if (startPart === 0 && isAbsolute2)
+      if (startPart === 0 && isAbsolute)
         ret.base = ret.name = path.slice(1, end);
       else
         ret.base = ret.name = path.slice(startPart, end);
   } else {
-    if (startPart === 0 && isAbsolute2)
+    if (startPart === 0 && isAbsolute)
       ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
     else
       ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
@@ -13685,7 +13682,7 @@ function parse(path) {
   }
   if (startPart > 0)
     ret.dir = path.slice(0, startPart - 1);
-  else if (isAbsolute2)
+  else if (isAbsolute)
     ret.dir = "/";
   return ret;
 }
@@ -13697,7 +13694,7 @@ var init_path = __esm(() => {
 // tools/test/src/visual/compare.ts
 var {readFileSync, writeFileSync} = (() => ({}));
 
-// ../../node_modules/.bun/pixelmatch@7.2.0/node_modules/pixelmatch/index.js
+// ../../node_modules/.bun/pixelmatch@8.0.0/node_modules/pixelmatch/index.js
 function pixelmatch(img1, img2, output, width, height, options = {}) {
   const {
     threshold = 0.1,
@@ -13705,22 +13702,26 @@ function pixelmatch(img1, img2, output, width, height, options = {}) {
     aaColor = [255, 255, 0],
     diffColor = [255, 0, 0],
     checkerboard = true,
+    windowSize = Infinity,
     includeAA,
     diffColorAlt,
-    diffMask
+    diffMask,
+    ignoreMask
   } = options;
-  if (!isPixelData(img1) || !isPixelData(img2) || output && !isPixelData(output))
+  if (!isPixelData(img1) || !isPixelData(img2) || output && !isPixelData(output) || ignoreMask && !isPixelData(ignoreMask))
     throw new Error("Image data: Uint8Array, Uint8ClampedArray or Buffer expected.");
   if (img1.length !== img2.length || output && output.length !== img1.length)
     throw new Error(`Image sizes do not match. Image 1 size: ${img1.length}, image 2 size: ${img2.length}`);
-  if (img1.length !== width * height * 4)
-    throw new Error(`Image data size does not match width/height. Expecting ${width * height * 4}. Got ${img1.length}`);
   const len = width * height;
+  if (img1.length !== len * 4)
+    throw new Error(`Image data size does not match width/height. Expecting ${len * 4}. Got ${img1.length}`);
+  if (ignoreMask && ignoreMask.length !== len)
+    throw new Error(`Ignore mask size does not match image width/height. Expecting ${len}. Got ${ignoreMask.length}`);
   const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
   const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
   let identical = true;
   for (let i = 0;i < len; i++) {
-    if (a32[i] !== b32[i]) {
+    if (a32[i] !== b32[i] && (!ignoreMask || !ignoreMask[i])) {
       identical = false;
       break;
     }
@@ -13728,24 +13729,28 @@ function pixelmatch(img1, img2, output, width, height, options = {}) {
   if (identical) {
     if (output && !diffMask) {
       for (let i = 0, pos = 0;i < len; i++, pos += 4)
-        drawGrayPixel(img1, pos, alpha, output);
+        drawGrayPixel(output, pos, img1, alpha);
     }
     return 0;
   }
-  const maxDelta = 35215 * threshold * threshold;
   const [aaR, aaG, aaB] = aaColor;
   const [diffR, diffG, diffB] = diffColor;
   const [altR, altG, altB] = diffColorAlt || diffColor;
   let diff = 0;
+  const mask = Number.isFinite(windowSize) ? new Uint8Array(len) : null;
+  let firstDiffY = -1;
+  let lastDiffY = 0;
   for (let i = 0, pos = 0;i < len; i++, pos += 4) {
-    const delta = a32[i] === b32[i] ? 0 : colorDelta(img1, img2, pos, pos, checkerboard);
-    if (Math.abs(delta) > maxDelta) {
+    const delta = a32[i] === b32[i] || ignoreMask && ignoreMask[i] ? 0 : colorDelta(img1, img2, pos, checkerboard, threshold);
+    if (delta) {
       const x = i % width;
       const y = i / width | 0;
-      const isExcludedAA = !includeAA && (antialiased(img1, x, y, width, height, a32, b32, checkerboard) || antialiased(img2, x, y, width, height, b32, a32, checkerboard));
+      const isExcludedAA = !includeAA && (antialiased(img1, x, y, width, height, a32, b32) || antialiased(img2, x, y, width, height, b32, a32));
       if (isExcludedAA) {
         if (output && !diffMask)
           drawPixel(output, pos, aaR, aaG, aaB);
+        if (mask)
+          mask[i] = 2;
       } else {
         if (output) {
           if (delta < 0) {
@@ -13754,22 +13759,66 @@ function pixelmatch(img1, img2, output, width, height, options = {}) {
             drawPixel(output, pos, diffR, diffG, diffB);
           }
         }
+        if (mask) {
+          mask[i] = 1;
+          if (firstDiffY < 0)
+            firstDiffY = y;
+          lastDiffY = y;
+        }
         diff++;
       }
     } else if (output && !diffMask) {
-      drawGrayPixel(img1, pos, alpha, output);
+      drawGrayPixel(output, pos, img1, alpha);
+    }
+  }
+  if (!mask || !diff)
+    return diff;
+  const n = Math.min(Math.max(Math.floor(windowSize), 1), width, height);
+  const colSum = new Uint16Array(width);
+  let maxCount = 0;
+  let bandTotal = 0;
+  const yEnd = Math.min(height - 1, lastDiffY + n - 1);
+  for (let y = firstDiffY;y <= yEnd; y++) {
+    const rowStart = y * width;
+    const leaving = y - n;
+    if (leaving >= 0) {
+      const leavingStart = leaving * width;
+      for (let x = 0;x < width; x++) {
+        const d = (mask[rowStart + x] & 1) - (mask[leavingStart + x] & 1);
+        colSum[x] += d;
+        bandTotal += d;
+      }
+    } else {
+      for (let x = 0;x < width; x++) {
+        const e = mask[rowStart + x] & 1;
+        colSum[x] += e;
+        bandTotal += e;
+      }
+      if (y < n - 1)
+        continue;
+    }
+    if (bandTotal <= maxCount)
+      continue;
+    let windowSum = 0;
+    for (let x = 0;x < n - 1; x++)
+      windowSum += colSum[x];
+    for (let x = n - 1;x < width; x++) {
+      windowSum += colSum[x];
+      if (windowSum > maxCount)
+        maxCount = windowSum;
+      windowSum -= colSum[x - n + 1];
     }
   }
-  return diff;
+  return maxCount;
 }
 function isPixelData(arr) {
   return ArrayBuffer.isView(arr) && arr.BYTES_PER_ELEMENT === 1;
 }
-function antialiased(img, x1, y1, width, height, a32, b32, checkerboard) {
-  const x0 = Math.max(x1 - 1, 0);
-  const y0 = Math.max(y1 - 1, 0);
-  const x2 = Math.min(x1 + 1, width - 1);
-  const y2 = Math.min(y1 + 1, height - 1);
+function antialiased(img, x1, y1, width, height, a32, b32) {
+  const x0 = x1 > 0 ? x1 - 1 : 0;
+  const y0 = y1 > 0 ? y1 - 1 : 0;
+  const x2 = x1 < width - 1 ? x1 + 1 : width - 1;
+  const y2 = y1 < height - 1 ? y1 + 1 : height - 1;
   const pos4 = (y1 * width + x1) * 4;
   const cr = img[pos4];
   const cg = img[pos4 + 1];
@@ -13782,11 +13831,13 @@ function antialiased(img, x1, y1, width, height, a32, b32, checkerboard) {
   let minY = 0;
   let maxX = 0;
   let maxY = 0;
+  const rowStep = width * 4;
   for (let x = x0;x <= x2; x++) {
-    for (let y = y0;y <= y2; y++) {
+    let m = (y0 * width + x) * 4;
+    for (let y = y0;y <= y2; y++, m += rowStep) {
       if (x === x1 && y === y1)
         continue;
-      const delta = brightnessDelta(img, pos4, (y * width + x) * 4, cr, cg, cb, ca, checkerboard);
+      const delta = brightnessDelta(img, m, cr, cg, cb, ca);
       if (delta === 0) {
         zeroes++;
         if (zeroes > 2)
@@ -13807,54 +13858,180 @@ function antialiased(img, x1, y1, width, height, a32, b32, checkerboard) {
   return hasManySiblings(a32, minX, minY, width, height) && hasManySiblings(b32, minX, minY, width, height) || hasManySiblings(a32, maxX, maxY, width, height) && hasManySiblings(b32, maxX, maxY, width, height);
 }
 function hasManySiblings(img, x1, y1, width, height) {
-  const x0 = Math.max(x1 - 1, 0);
-  const y0 = Math.max(y1 - 1, 0);
-  const x2 = Math.min(x1 + 1, width - 1);
-  const y2 = Math.min(y1 + 1, height - 1);
-  const val = img[y1 * width + x1];
+  const pos1 = y1 * width + x1;
+  const val = img[pos1];
+  if (x1 > 0 && x1 < width - 1 && y1 > 0 && y1 < height - 1) {
+    return +(val === img[pos1 - width - 1]) + +(val === img[pos1 - 1]) + +(val === img[pos1 + width - 1]) + +(val === img[pos1 - width]) + +(val === img[pos1 + width]) + +(val === img[pos1 - width + 1]) + +(val === img[pos1 + 1]) + +(val === img[pos1 + width + 1]) > 2;
+  }
+  const x0 = x1 > 0 ? x1 - 1 : 0;
+  const y0 = y1 > 0 ? y1 - 1 : 0;
+  const x2 = x1 < width - 1 ? x1 + 1 : width - 1;
+  const y2 = y1 < height - 1 ? y1 + 1 : height - 1;
   let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
   for (let x = x0;x <= x2; x++) {
-    for (let y = y0;y <= y2; y++) {
+    let pos = y0 * width + x;
+    for (let y = y0;y <= y2; y++, pos += width) {
       if (x === x1 && y === y1)
         continue;
-      zeroes += +(val === img[y * width + x]);
+      zeroes += +(val === img[pos]);
       if (zeroes > 2)
         return true;
     }
   }
   return false;
 }
-function colorDelta(img1, img2, k, m, checkerboard) {
+var LIN = new Float64Array(257);
+for (let i = 0;i < 256; i++) {
+  const c = i / 255;
+  LIN[i] = c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+LIN[256] = LIN[255];
+var L_R = new Float64Array(256);
+var L_G = new Float64Array(256);
+var L_B = new Float64Array(256);
+var M_R = new Float64Array(256);
+var M_G = new Float64Array(256);
+var M_B = new Float64Array(256);
+var S_R = new Float64Array(256);
+var S_G = new Float64Array(256);
+var S_B = new Float64Array(256);
+for (let i = 0;i < 256; i++) {
+  const lr = LIN[i];
+  L_R[i] = 0.4122214708 * lr;
+  M_R[i] = 0.2119034982 * lr;
+  S_R[i] = 0.0883024619 * lr;
+  L_G[i] = 0.5363325363 * lr;
+  M_G[i] = 0.6806995451 * lr;
+  S_G[i] = 0.2817188376 * lr;
+  L_B[i] = 0.0514459929 * lr;
+  M_B[i] = 0.1073969566 * lr;
+  S_B[i] = 0.6299787005 * lr;
+}
+function linLUT(x) {
+  const i = x | 0;
+  return LIN[i] + (LIN[i + 1] - LIN[i]) * (x - i);
+}
+var CBRT_N = 4096;
+var CBRT = new Float64Array(CBRT_N + 2);
+for (let i = 0;i <= CBRT_N + 1; i++)
+  CBRT[i] = Math.cbrt(i / CBRT_N);
+var CBRT_EXACT = 8;
+function cbrtLUT(x) {
+  const t = x * CBRT_N;
+  const i = t | 0;
+  if (i < CBRT_EXACT)
+    return Math.cbrt(x);
+  return CBRT[i] + (CBRT[i + 1] - CBRT[i]) * (t - i);
+}
+var OKLAB_CACHE_BITS = 12;
+var OKLAB_CACHE_SHIFT = 32 - OKLAB_CACHE_BITS;
+var OKLAB_CACHE_SIZE = 1 << OKLAB_CACHE_BITS;
+var OKLAB_CACHE_KEYS = new Uint32Array(OKLAB_CACHE_SIZE);
+var OKLAB_CACHE_VALUES = new Float64Array(OKLAB_CACHE_SIZE * 4);
+var TOE_K1 = 0.206;
+var TOE_K2 = 0.03;
+var TOE_K3 = (1 + TOE_K1) / (1 + TOE_K2);
+function colorDelta(img1, img2, k, checkerboard, maxDelta) {
   const r1 = img1[k];
   const g1 = img1[k + 1];
   const b1 = img1[k + 2];
   const a1 = img1[k + 3];
-  const r2 = img2[m];
-  const g2 = img2[m + 1];
-  const b2 = img2[m + 2];
-  const a2 = img2[m + 3];
-  let dr = r1 - r2;
-  let dg = g1 - g2;
-  let db = b1 - b2;
-  const da = a1 - a2;
-  if (a1 < 255 || a2 < 255) {
-    let rb = 255, gb = 255, bb = 255;
-    if (checkerboard) {
-      rb = 48 + 159 * (k % 2);
-      gb = 48 + 159 * ((k / 1.618033988749895 | 0) % 2);
-      bb = 48 + 159 * ((k / 2.618033988749895 | 0) % 2);
-    }
-    dr = (r1 * a1 - r2 * a2 - rb * da) / 255;
-    dg = (g1 * a1 - g2 * a2 - gb * da) / 255;
-    db = (b1 * a1 - b2 * a2 - bb * da) / 255;
+  const r2 = img2[k];
+  const g2 = img2[k + 1];
+  const b2 = img2[k + 2];
+  const a2 = img2[k + 3];
+  if (a1 === 255 && a2 === 255) {
+    return colorDeltaOpaque(r1, g1, b1, r2, g2, b2, maxDelta);
+  }
+  return colorDeltaTransparent(r1, g1, b1, a1, r2, g2, b2, a2, k, checkerboard, maxDelta);
+}
+function colorDeltaOpaque(r1, g1, b1, r2, g2, b2, maxDelta) {
+  const key1 = r1 << 16 | g1 << 8 | b1;
+  const slot1 = Math.imul(key1, 2654435761) >>> OKLAB_CACHE_SHIFT;
+  const stored1 = key1 + 1;
+  const offset1 = slot1 * 4;
+  let l1, m1, s1, lr1;
+  if (OKLAB_CACHE_KEYS[slot1] === stored1) {
+    l1 = OKLAB_CACHE_VALUES[offset1];
+    m1 = OKLAB_CACHE_VALUES[offset1 + 1];
+    s1 = OKLAB_CACHE_VALUES[offset1 + 2];
+    lr1 = OKLAB_CACHE_VALUES[offset1 + 3];
+  } else {
+    l1 = cbrtLUT(L_R[r1] + L_G[g1] + L_B[b1]);
+    m1 = cbrtLUT(M_R[r1] + M_G[g1] + M_B[b1]);
+    s1 = cbrtLUT(S_R[r1] + S_G[g1] + S_B[b1]);
+    lr1 = lightness(l1, m1, s1);
+    OKLAB_CACHE_KEYS[slot1] = stored1;
+    OKLAB_CACHE_VALUES[offset1] = l1;
+    OKLAB_CACHE_VALUES[offset1 + 1] = m1;
+    OKLAB_CACHE_VALUES[offset1 + 2] = s1;
+    OKLAB_CACHE_VALUES[offset1 + 3] = lr1;
+  }
+  const key2 = r2 << 16 | g2 << 8 | b2;
+  const slot2 = Math.imul(key2, 2654435761) >>> OKLAB_CACHE_SHIFT;
+  const stored2 = key2 + 1;
+  const offset2 = slot2 * 4;
+  let l2, m2, s2, lr2;
+  if (OKLAB_CACHE_KEYS[slot2] === stored2) {
+    l2 = OKLAB_CACHE_VALUES[offset2];
+    m2 = OKLAB_CACHE_VALUES[offset2 + 1];
+    s2 = OKLAB_CACHE_VALUES[offset2 + 2];
+    lr2 = OKLAB_CACHE_VALUES[offset2 + 3];
+  } else {
+    l2 = cbrtLUT(L_R[r2] + L_G[g2] + L_B[b2]);
+    m2 = cbrtLUT(M_R[r2] + M_G[g2] + M_B[b2]);
+    s2 = cbrtLUT(S_R[r2] + S_G[g2] + S_B[b2]);
+    lr2 = lightness(l2, m2, s2);
+    OKLAB_CACHE_KEYS[slot2] = stored2;
+    OKLAB_CACHE_VALUES[offset2] = l2;
+    OKLAB_CACHE_VALUES[offset2 + 1] = m2;
+    OKLAB_CACHE_VALUES[offset2 + 2] = s2;
+    OKLAB_CACHE_VALUES[offset2 + 3] = lr2;
   }
-  const y = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
-  const i = dr * 0.59597799 - dg * 0.2741761 - db * 0.32180189;
-  const q = dr * 0.21147017 - dg * 0.52261711 + db * 0.31114694;
-  const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
-  return y > 0 ? -delta : delta;
+  return oklabHyabDelta(lr1 - lr2, l1 - l2, m1 - m2, s1 - s2, maxDelta);
+}
+function colorDeltaTransparent(r1, g1, b1, a1, r2, g2, b2, a2, k, checkerboard, maxDelta) {
+  let rb = 255, gb = 255, bb = 255;
+  if (checkerboard) {
+    const h = Math.imul(k >> 2, 2654435761);
+    rb = 48 + 159 * (h >>> 31);
+    gb = 48 + 159 * (h >>> 30 & 1);
+    bb = 48 + 159 * (h >>> 29 & 1);
+  }
+  r1 = (r1 * a1 + rb * (255 - a1)) / 255;
+  g1 = (g1 * a1 + gb * (255 - a1)) / 255;
+  b1 = (b1 * a1 + bb * (255 - a1)) / 255;
+  r2 = (r2 * a2 + rb * (255 - a2)) / 255;
+  g2 = (g2 * a2 + gb * (255 - a2)) / 255;
+  b2 = (b2 * a2 + bb * (255 - a2)) / 255;
+  const lr1 = linLUT(r1), lg1 = linLUT(g1), lb1 = linLUT(b1);
+  const lr2 = linLUT(r2), lg2 = linLUT(g2), lb2 = linLUT(b2);
+  const l1 = cbrtLUT(0.4122214708 * lr1 + 0.5363325363 * lg1 + 0.0514459929 * lb1);
+  const m1 = cbrtLUT(0.2119034982 * lr1 + 0.6806995451 * lg1 + 0.1073969566 * lb1);
+  const s1 = cbrtLUT(0.0883024619 * lr1 + 0.2817188376 * lg1 + 0.6299787005 * lb1);
+  const l2 = cbrtLUT(0.4122214708 * lr2 + 0.5363325363 * lg2 + 0.0514459929 * lb2);
+  const m2 = cbrtLUT(0.2119034982 * lr2 + 0.6806995451 * lg2 + 0.1073969566 * lb2);
+  const s2 = cbrtLUT(0.0883024619 * lr2 + 0.2817188376 * lg2 + 0.6299787005 * lb2);
+  const Lr1 = lightness(l1, m1, s1);
+  const Lr2 = lightness(l2, m2, s2);
+  return oklabHyabDelta(Lr1 - Lr2, l1 - l2, m1 - m2, s1 - s2, maxDelta);
+}
+function oklabHyabDelta(dLr, dl, dm, ds, maxDelta) {
+  const rest = maxDelta - Math.abs(dLr);
+  if (rest >= 0) {
+    const da = 1.9779984951 * dl - 2.428592205 * dm + 0.4505937099 * ds;
+    const db = 0.0259040371 * dl + 0.7827717662 * dm - 0.808675766 * ds;
+    if (da * da + db * db <= rest * rest)
+      return 0;
+  }
+  return dLr > 0 ? -1 : 1;
+}
+function lightness(l, m, s) {
+  const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
+  const x = TOE_K3 * L - TOE_K1;
+  return 0.5 * (x + Math.sqrt(x * x + 4 * TOE_K2 * TOE_K3 * L));
 }
-function brightnessDelta(img, k, m, r1, g1, b1, a1, checkerboard) {
+function brightnessDelta(img, m, r1, g1, b1, a1) {
   const r2 = img[m];
   const g2 = img[m + 1];
   const b2 = img[m + 2];
@@ -13866,15 +14043,11 @@ function brightnessDelta(img, k, m, r1, g1, b1, a1, checkerboard) {
   if (!dr && !dg && !db && !da)
     return 0;
   if (a1 < 255 || a2 < 255) {
-    let rb = 255, gb = 255, bb = 255;
-    if (checkerboard) {
-      rb = 48 + 159 * (k % 2);
-      gb = 48 + 159 * ((k / 1.618033988749895 | 0) % 2);
-      bb = 48 + 159 * ((k / 2.618033988749895 | 0) % 2);
-    }
-    dr = (r1 * a1 - r2 * a2 - rb * da) / 255;
-    dg = (g1 * a1 - g2 * a2 - gb * da) / 255;
-    db = (b1 * a1 - b2 * a2 - bb * da) / 255;
+    dr = (r1 * a1 - r2 * a2 - 255 * da) / 255;
+    dg = (g1 * a1 - g2 * a2 - 255 * da) / 255;
+    db = (b1 * a1 - b2 * a2 - 255 * da) / 255;
+    const d = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+    return d === 0 && da ? da / 2 : d;
   }
   return dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
 }
@@ -13884,7 +14057,7 @@ function drawPixel(output, pos, r, g, b) {
   output[pos + 2] = b;
   output[pos + 3] = 255;
 }
-function drawGrayPixel(img, i, alpha, output) {
+function drawGrayPixel(output, i, img, alpha) {
   const val = 255 + (img[i] * 0.29889531 + img[i + 1] * 0.58662247 + img[i + 2] * 0.11448223 - 255) * alpha * img[i + 3] / 255;
   drawPixel(output, i, val, val, val);
 }
@@ -14016,4 +14189,4 @@ export {
   resolveVisualPaths
 };
 
-//# debugId=6451E795FF7C348864756E2164756E21
+//# debugId=6DA2B08A2421170464756E2164756E21