@aguacerowx/mapsgl 0.0.31 → 0.0.41

package/src/nexrad/radarArchiveCore.bundled.js

@@ -0,0 +1,4206 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "../../node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code.length; i < len; ++i) {
+      lookup[i] = code[i];
+      revLookup[code.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new 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;
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var 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;
+      }
+      if (placeHoldersLen === 2) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 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;
+      }
+      return arr;
+    }
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var 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));
+      }
+      return output.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      var extraBytes = len2 % 3;
+      var parts = [];
+      var maxChunkLength = 16383;
+      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 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] + "="
+        );
+      }
+      return parts.join("");
+    }
+  }
+});
+
+// ../../node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "../../node_modules/ieee754/index.js"(exports) {
+    exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var 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 + i], i += d, nBits -= 8) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+      var i = isLE ? 0 : nBytes - 1;
+      var d = isLE ? 1 : -1;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      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 + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      }
+      buffer[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "node_modules/buffer/index.js"(exports) {
+    "use strict";
+    var base64 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    exports.Buffer = Buffer3;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+      );
+    }
+    function typedArraySupport() {
+      try {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
+          return 42;
+        } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    Object.defineProperty(Buffer3.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer3.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.byteOffset;
+      }
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length + '" is invalid for option "size"');
+      }
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function Buffer3(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError(
+            'The "string" argument must be of type string. Received type number'
+          );
+        }
+        return allocUnsafe(arg);
+      }
+      return from(arg, encodingOrOffset, length);
+    }
+    Buffer3.poolSize = 8192;
+    function from(value, encodingOrOffset, length) {
+      if (typeof value === "string") {
+        return fromString(value, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
+      }
+      if (value == null) {
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+        );
+      }
+      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof value === "number") {
+        throw new TypeError(
+          'The "value" argument must not be of type number. Received type number'
+        );
+      }
+      const valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer3.from(valueOf, encodingOrOffset, length);
+      }
+      const b = fromObject(value);
+      if (b) return b;
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+      }
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    }
+    Buffer3.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer3, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError('The value "' + size + '" is invalid for option "size"');
+      }
+    }
+    function alloc(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    Buffer3.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer3.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer3.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    function fromArrayLike(array) {
+      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+      const buf = createBuffer(length);
+      for (let i = 0; i < length; i += 1) {
+        buf[i] = array[i] & 255;
+      }
+      return buf;
+    }
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    function fromArrayBuffer(array, byteOffset, length) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      let buf;
+      if (byteOffset === void 0 && length === void 0) {
+        buf = new Uint8Array(array);
+      } else if (length === void 0) {
+        buf = new Uint8Array(array, byteOffset);
+      } else {
+        buf = new Uint8Array(array, byteOffset, length);
+      }
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer3.isBuffer(obj)) {
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
+        if (buf.length === 0) {
+          return buf;
+        }
+        obj.copy(buf, 0, 0, len);
+        return buf;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike(obj.data);
+      }
+    }
+    function checked(length) {
+      if (length >= K_MAX_LENGTH) {
+        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+      }
+      return length | 0;
+    }
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer3.alloc(+length);
+    }
+    Buffer3.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+    };
+    Buffer3.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array)) a = Buffer3.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array)) b = Buffer3.from(b, b.offset, b.byteLength);
+      if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+        throw new TypeError(
+          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+        );
+      }
+      if (a === b) return 0;
+      let x = a.length;
+      let y = b.length;
+      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) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    Buffer3.isEncoding = function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    };
+    Buffer3.concat = function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer3.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer3.allocUnsafe(length);
+      let pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        let buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer3.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    };
+    function byteLength(string, encoding) {
+      if (Buffer3.isBuffer(string)) {
+        return string.length;
+      }
+      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+        return string.byteLength;
+      }
+      if (typeof string !== "string") {
+        throw new TypeError(
+          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+        );
+      }
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0) return 0;
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes(string).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes(string).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes(string).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      let loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding) encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    Buffer3.prototype.swap16 = function swap16() {
+      const len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (let i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap32 = function swap32() {
+      const len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (let i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap64 = function swap64() {
+      const len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      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;
+    };
+    Buffer3.prototype.toString = function toString() {
+      const length = this.length;
+      if (length === 0) return "";
+      if (arguments.length === 0) return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    };
+    Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+    Buffer3.prototype.equals = function equals(b) {
+      if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer3.compare(this, b) === 0;
+    };
+    Buffer3.prototype.inspect = function inspect() {
+      let str = "";
+      const max = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max) str += " ... ";
+      return "<Buffer " + str + ">";
+    };
+    if (customInspectSymbol) {
+      Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+    }
+    Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer3.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer3.isBuffer(target)) {
+        throw new TypeError(
+          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+        );
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target) return 0;
+      let x = thisEnd - thisStart;
+      let y = end - start;
+      const len = Math.min(x, y);
+      const thisCopy = this.slice(thisStart, thisEnd);
+      const 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) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+      if (buffer.length === 0) return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+      if (byteOffset >= buffer.length) {
+        if (dir) return -1;
+        else byteOffset = buffer.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir) byteOffset = 0;
+        else return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer3.from(val, encoding);
+      }
+      if (Buffer3.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+          }
+        }
+        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read(buf, i2) {
+        if (indexSize === 1) {
+          return buf[i2];
+        } else {
+          return buf.readUInt16BE(i2 * indexSize);
+        }
+      }
+      let i;
+      if (dir) {
+        let foundIndex = -1;
+        for (i = byteOffset; i < arrLength; i++) {
+          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+            if (foundIndex === -1) foundIndex = i;
+            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+          } else {
+            if (foundIndex !== -1) i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    };
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      const remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      const strLen = string.length;
+      if (length > strLen / 2) {
+        length = strLen / 2;
+      }
+      let i;
+      for (i = 0; i < length; ++i) {
+        const parsed = parseInt(string.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed)) return i;
+        buf[offset + i] = parsed;
+      }
+      return i;
+    }
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    Buffer3.prototype.write = function write(string, offset, length, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length = this.length;
+        offset = 0;
+      } else if (length === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length)) {
+          length = length >>> 0;
+          if (encoding === void 0) encoding = "utf8";
+        } else {
+          encoding = length;
+          length = void 0;
+        }
+      } else {
+        throw new Error(
+          "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+        );
+      }
+      const remaining = this.length - offset;
+      if (length === void 0 || length > remaining) length = remaining;
+      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding) encoding = "utf8";
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string, offset, length);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string, offset, length);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string, offset, length);
+          case "base64":
+            return base64Write(this, string, offset, length);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string, offset, length);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    };
+    Buffer3.prototype.toJSON = function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    };
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      const res = [];
+      let i = start;
+      while (i < end) {
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              fourthByte = buf[i + 3];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(codePoint >>> 10 & 1023 | 55296);
+          codePoint = 56320 | codePoint & 1023;
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray(res);
+    }
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      const len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      let res = "";
+      let 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 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 i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i]);
+      }
+      return ret;
+    }
+    function hexSlice(buf, start, end) {
+      const len = buf.length;
+      if (!start || start < 0) start = 0;
+      if (!end || end < 0 || end > len) end = len;
+      let out = "";
+      for (let i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf[i]];
+      }
+      return out;
+    }
+    function utf16leSlice(buf, start, end) {
+      const bytes = buf.slice(start, end);
+      let res = "";
+      for (let i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    Buffer3.prototype.slice = function slice(start, end) {
+      const len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0) start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0) end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start) end = start;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer3.prototype);
+      return newBuf;
+    };
+    function checkOffset(offset, ext, length) {
+      if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+      if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+    }
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      let val = this[offset + --byteLength2];
+      let mul = 1;
+      while (byteLength2 > 0 && (mul *= 256)) {
+        val += this[offset + --byteLength2] * mul;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      return this[offset];
+    };
+    Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    };
+    Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    };
+    Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+    };
+    Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+    };
+    Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+      return BigInt(lo) + (BigInt(hi) << BigInt(32));
+    });
+    Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    });
+    Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let i = byteLength2;
+      let mul = 1;
+      let val = this[offset + --i];
+      while (i > 0 && (mul *= 256)) {
+        val += this[offset + --i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128)) return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    };
+    Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+    };
+    Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+    };
+    Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+    });
+    Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = (first << 24) + // Overflow
+      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+    });
+    Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    };
+    function checkInt(buf, value, offset, ext, max, min) {
+      if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+      if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+    }
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let mul = 1;
+      let i = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset + 3] = value >>> 24;
+      this[offset + 2] = value >>> 16;
+      this[offset + 1] = value >>> 8;
+      this[offset] = value & 255;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    function wrtBigUInt64LE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      return offset;
+    }
+    function wrtBigUInt64BE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset + 7] = lo;
+      lo = lo >> 8;
+      buf[offset + 6] = lo;
+      lo = lo >> 8;
+      buf[offset + 5] = lo;
+      lo = lo >> 8;
+      buf[offset + 4] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset + 3] = hi;
+      hi = hi >> 8;
+      buf[offset + 2] = hi;
+      hi = hi >> 8;
+      buf[offset + 1] = hi;
+      hi = hi >> 8;
+      buf[offset] = hi;
+      return offset + 8;
+    }
+    Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = 0;
+      let mul = 1;
+      let sub = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      let 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 + i] = (value / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0) value = 255 + value + 1;
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0) value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    function checkIEEE754(buf, value, offset, ext, max, min) {
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+      if (offset < 0) throw new RangeError("Index out of range");
+    }
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
+    };
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    };
+    Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+      if (!start) start = 0;
+      if (!end && end !== 0) end = this.length;
+      if (targetStart >= target.length) targetStart = target.length;
+      if (!targetStart) targetStart = 0;
+      if (end > 0 && end < start) end = start;
+      if (end === start) return 0;
+      if (target.length === 0 || this.length === 0) return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+      if (end < 0) throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length) end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      const 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 len;
+    };
+    Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          const code = val.charCodeAt(0);
+          if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+            val = code;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val) val = 0;
+      let i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+        const len = bytes.length;
+        if (len === 0) {
+          throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+        }
+        for (i = 0; i < end - start; ++i) {
+          this[i + start] = bytes[i % len];
+        }
+      }
+      return this;
+    };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[sym] = class NodeError extends Base {
+        constructor() {
+          super();
+          Object.defineProperty(this, "message", {
+            value: getMessage.apply(this, arguments),
+            writable: true,
+            configurable: true
+          });
+          this.name = `${this.name} [${sym}]`;
+          this.stack;
+          delete this.name;
+        }
+        get code() {
+          return sym;
+        }
+        set code(value) {
+          Object.defineProperty(this, "code", {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true
+          });
+        }
+        toString() {
+          return `${this.name} [${sym}]: ${this.message}`;
+        }
+      };
+    }
+    E(
+      "ERR_BUFFER_OUT_OF_BOUNDS",
+      function(name) {
+        if (name) {
+          return `${name} is outside of buffer bounds`;
+        }
+        return "Attempt to access memory outside buffer bounds";
+      },
+      RangeError
+    );
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      function(name, actual) {
+        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      function(str, range, input) {
+        let msg = `The value of "${str}" is out of range.`;
+        let received = input;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        }
+        msg += ` It must be ${range}. Received ${received}`;
+        return msg;
+      },
+      RangeError
+    );
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const 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) {
+      validateNumber(offset, "offset");
+      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+        boundsError(offset, buf.length - (byteLength2 + 1));
+      }
+    }
+    function checkIntBI(value, min, max, buf, offset, byteLength2) {
+      if (value > max || value < min) {
+        const n = typeof min === "bigint" ? "n" : "";
+        let range;
+        if (byteLength2 > 3) {
+          if (min === 0 || min === BigInt(0)) {
+            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+          } else {
+            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+          }
+        } else {
+          range = `>= ${min}${n} and <= ${max}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+    }
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value
+      );
+    }
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2) return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes = [];
+      for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        if (codePoint > 55295 && codePoint < 57344) {
+          if (!leadSurrogate) {
+            if (codePoint > 56319) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            } else if (i + 1 === length) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1) bytes.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0) break;
+          bytes.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0) break;
+          bytes.push(
+            codePoint >> 6 | 192,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0) break;
+          bytes.push(
+            codePoint >> 12 | 224,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0) break;
+          bytes.push(
+            codePoint >> 18 | 240,
+            codePoint >> 12 & 63 | 128,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes;
+    }
+    function asciiToBytes(str) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    function utf16leToBytes(str, units) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0) break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    function base64ToBytes(str) {
+      return base64.toByteArray(base64clean(str));
+    }
+    function blitBuffer(src, dst, offset, length) {
+      let i;
+      for (i = 0; i < length; ++i) {
+        if (i + offset >= dst.length || i >= src.length) break;
+        dst[i + offset] = src[i];
+      }
+      return i;
+    }
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    var hexSliceLookupTable = function() {
+      const alphabet = "0123456789abcdef";
+      const table = new Array(256);
+      for (let i = 0; i < 16; ++i) {
+        const i16 = i * 16;
+        for (let j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table;
+    }();
+    function defineBigIntMethod(fn) {
+      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+    }
+    function BufferBigIntNotDefined() {
+      throw new Error("BigInt not supported");
+    }
+  }
+});
+
+// ../../node_modules/seek-bzip/lib/bitreader.js
+var require_bitreader = __commonJS({
+  "../../node_modules/seek-bzip/lib/bitreader.js"(exports, module) {
+    var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255];
+    var BitReader = function(stream) {
+      this.stream = stream;
+      this.bitOffset = 0;
+      this.curByte = 0;
+      this.hasByte = false;
+    };
+    BitReader.prototype._ensureByte = function() {
+      if (!this.hasByte) {
+        this.curByte = this.stream.readByte();
+        this.hasByte = true;
+      }
+    };
+    BitReader.prototype.read = function(bits) {
+      var result = 0;
+      while (bits > 0) {
+        this._ensureByte();
+        var remaining = 8 - this.bitOffset;
+        if (bits >= remaining) {
+          result <<= remaining;
+          result |= BITMASK[remaining] & this.curByte;
+          this.hasByte = false;
+          this.bitOffset = 0;
+          bits -= remaining;
+        } else {
+          result <<= bits;
+          var shift = remaining - bits;
+          result |= (this.curByte & BITMASK[bits] << shift) >> shift;
+          this.bitOffset += bits;
+          bits = 0;
+        }
+      }
+      return result;
+    };
+    BitReader.prototype.seek = function(pos) {
+      var n_bit = pos % 8;
+      var n_byte = (pos - n_bit) / 8;
+      this.bitOffset = n_bit;
+      this.stream.seek(n_byte);
+      this.hasByte = false;
+    };
+    BitReader.prototype.pi = function() {
+      var buf = new Buffer(6), i;
+      for (i = 0; i < buf.length; i++) {
+        buf[i] = this.read(8);
+      }
+      return buf.toString("hex");
+    };
+    module.exports = BitReader;
+  }
+});
+
+// ../../node_modules/seek-bzip/lib/stream.js
+var require_stream = __commonJS({
+  "../../node_modules/seek-bzip/lib/stream.js"(exports, module) {
+    var Stream = function() {
+    };
+    Stream.prototype.readByte = function() {
+      throw new Error("abstract method readByte() not implemented");
+    };
+    Stream.prototype.read = function(buffer, bufOffset, length) {
+      var bytesRead = 0;
+      while (bytesRead < length) {
+        var c = this.readByte();
+        if (c < 0) {
+          return bytesRead === 0 ? -1 : bytesRead;
+        }
+        buffer[bufOffset++] = c;
+        bytesRead++;
+      }
+      return bytesRead;
+    };
+    Stream.prototype.seek = function(new_pos) {
+      throw new Error("abstract method seek() not implemented");
+    };
+    Stream.prototype.writeByte = function(_byte) {
+      throw new Error("abstract method readByte() not implemented");
+    };
+    Stream.prototype.write = function(buffer, bufOffset, length) {
+      var i;
+      for (i = 0; i < length; i++) {
+        this.writeByte(buffer[bufOffset++]);
+      }
+      return length;
+    };
+    Stream.prototype.flush = function() {
+    };
+    module.exports = Stream;
+  }
+});
+
+// ../../node_modules/seek-bzip/lib/crc32.js
+var require_crc32 = __commonJS({
+  "../../node_modules/seek-bzip/lib/crc32.js"(exports, module) {
+    module.exports = function() {
+      var crc32Lookup = new Uint32Array([
+        0,
+        79764919,
+        159529838,
+        222504665,
+        319059676,
+        398814059,
+        445009330,
+        507990021,
+        638119352,
+        583659535,
+        797628118,
+        726387553,
+        890018660,
+        835552979,
+        1015980042,
+        944750013,
+        1276238704,
+        1221641927,
+        1167319070,
+        1095957929,
+        1595256236,
+        1540665371,
+        1452775106,
+        1381403509,
+        1780037320,
+        1859660671,
+        1671105958,
+        1733955601,
+        2031960084,
+        2111593891,
+        1889500026,
+        1952343757,
+        2552477408,
+        2632100695,
+        2443283854,
+        2506133561,
+        2334638140,
+        2414271883,
+        2191915858,
+        2254759653,
+        3190512472,
+        3135915759,
+        3081330742,
+        3009969537,
+        2905550212,
+        2850959411,
+        2762807018,
+        2691435357,
+        3560074640,
+        3505614887,
+        3719321342,
+        3648080713,
+        3342211916,
+        3287746299,
+        3467911202,
+        3396681109,
+        4063920168,
+        4143685023,
+        4223187782,
+        4286162673,
+        3779000052,
+        3858754371,
+        3904687514,
+        3967668269,
+        881225847,
+        809987520,
+        1023691545,
+        969234094,
+        662832811,
+        591600412,
+        771767749,
+        717299826,
+        311336399,
+        374308984,
+        453813921,
+        533576470,
+        25881363,
+        88864420,
+        134795389,
+        214552010,
+        2023205639,
+        2086057648,
+        1897238633,
+        1976864222,
+        1804852699,
+        1867694188,
+        1645340341,
+        1724971778,
+        1587496639,
+        1516133128,
+        1461550545,
+        1406951526,
+        1302016099,
+        1230646740,
+        1142491917,
+        1087903418,
+        2896545431,
+        2825181984,
+        2770861561,
+        2716262478,
+        3215044683,
+        3143675388,
+        3055782693,
+        3001194130,
+        2326604591,
+        2389456536,
+        2200899649,
+        2280525302,
+        2578013683,
+        2640855108,
+        2418763421,
+        2498394922,
+        3769900519,
+        3832873040,
+        3912640137,
+        3992402750,
+        4088425275,
+        4151408268,
+        4197601365,
+        4277358050,
+        3334271071,
+        3263032808,
+        3476998961,
+        3422541446,
+        3585640067,
+        3514407732,
+        3694837229,
+        3640369242,
+        1762451694,
+        1842216281,
+        1619975040,
+        1682949687,
+        2047383090,
+        2127137669,
+        1938468188,
+        2001449195,
+        1325665622,
+        1271206113,
+        1183200824,
+        1111960463,
+        1543535498,
+        1489069629,
+        1434599652,
+        1363369299,
+        622672798,
+        568075817,
+        748617968,
+        677256519,
+        907627842,
+        853037301,
+        1067152940,
+        995781531,
+        51762726,
+        131386257,
+        177728840,
+        240578815,
+        269590778,
+        349224269,
+        429104020,
+        491947555,
+        4046411278,
+        4126034873,
+        4172115296,
+        4234965207,
+        3794477266,
+        3874110821,
+        3953728444,
+        4016571915,
+        3609705398,
+        3555108353,
+        3735388376,
+        3664026991,
+        3290680682,
+        3236090077,
+        3449943556,
+        3378572211,
+        3174993278,
+        3120533705,
+        3032266256,
+        2961025959,
+        2923101090,
+        2868635157,
+        2813903052,
+        2742672763,
+        2604032198,
+        2683796849,
+        2461293480,
+        2524268063,
+        2284983834,
+        2364738477,
+        2175806836,
+        2238787779,
+        1569362073,
+        1498123566,
+        1409854455,
+        1355396672,
+        1317987909,
+        1246755826,
+        1192025387,
+        1137557660,
+        2072149281,
+        2135122070,
+        1912620623,
+        1992383480,
+        1753615357,
+        1816598090,
+        1627664531,
+        1707420964,
+        295390185,
+        358241886,
+        404320391,
+        483945776,
+        43990325,
+        106832002,
+        186451547,
+        266083308,
+        932423249,
+        861060070,
+        1041341759,
+        986742920,
+        613929101,
+        542559546,
+        756411363,
+        701822548,
+        3316196985,
+        3244833742,
+        3425377559,
+        3370778784,
+        3601682597,
+        3530312978,
+        3744426955,
+        3689838204,
+        3819031489,
+        3881883254,
+        3928223919,
+        4007849240,
+        4037393693,
+        4100235434,
+        4180117107,
+        4259748804,
+        2310601993,
+        2373574846,
+        2151335527,
+        2231098320,
+        2596047829,
+        2659030626,
+        2470359227,
+        2550115596,
+        2947551409,
+        2876312838,
+        2788305887,
+        2733848168,
+        3165939309,
+        3094707162,
+        3040238851,
+        2985771188
+      ]);
+      var CRC32 = function() {
+        var crc = 4294967295;
+        this.getCRC = function() {
+          return ~crc >>> 0;
+        };
+        this.updateCRC = function(value) {
+          crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
+        };
+        this.updateCRCRun = function(value, count) {
+          while (count-- > 0) {
+            crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
+          }
+        };
+      };
+      return CRC32;
+    }();
+  }
+});
+
+// ../../node_modules/seek-bzip/package.json
+var require_package = __commonJS({
+  "../../node_modules/seek-bzip/package.json"(exports, module) {
+    module.exports = {
+      name: "seek-bzip",
+      version: "2.0.0",
+      contributors: [
+        "C. Scott Ananian (http://cscott.net)",
+        "Eli Skeggs",
+        "Kevin Kwok",
+        "Rob Landley (http://landley.net)"
+      ],
+      description: "a pure-JavaScript Node.JS module for random-access decoding bzip2 data",
+      main: "./lib/index.js",
+      repository: {
+        type: "git",
+        url: "https://github.com/cscott/seek-bzip.git"
+      },
+      license: "MIT",
+      bin: {
+        "seek-bunzip": "./bin/seek-bunzip",
+        "seek-table": "./bin/seek-bzip-table"
+      },
+      directories: {
+        test: "test"
+      },
+      dependencies: {
+        commander: "^6.0.0"
+      },
+      devDependencies: {
+        fibers: "^5.0.0",
+        mocha: "^8.1.0"
+      },
+      scripts: {
+        test: "mocha"
+      }
+    };
+  }
+});
+
+// ../../node_modules/seek-bzip/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/seek-bzip/lib/index.js"(exports, module) {
+    var BitReader = require_bitreader();
+    var Stream = require_stream();
+    var CRC32 = require_crc32();
+    var pjson = require_package();
+    var MAX_HUFCODE_BITS = 20;
+    var MAX_SYMBOLS = 258;
+    var SYMBOL_RUNA = 0;
+    var SYMBOL_RUNB = 1;
+    var MIN_GROUPS = 2;
+    var MAX_GROUPS = 6;
+    var GROUP_SIZE = 50;
+    var WHOLEPI = "314159265359";
+    var SQRTPI = "177245385090";
+    var mtf = function(array, index) {
+      var src = array[index], i;
+      for (i = index; i > 0; i--) {
+        array[i] = array[i - 1];
+      }
+      array[0] = src;
+      return src;
+    };
+    var Err = {
+      OK: 0,
+      LAST_BLOCK: -1,
+      NOT_BZIP_DATA: -2,
+      UNEXPECTED_INPUT_EOF: -3,
+      UNEXPECTED_OUTPUT_EOF: -4,
+      DATA_ERROR: -5,
+      OUT_OF_MEMORY: -6,
+      OBSOLETE_INPUT: -7,
+      END_OF_BLOCK: -8
+    };
+    var ErrorMessages = {};
+    ErrorMessages[Err.LAST_BLOCK] = "Bad file checksum";
+    ErrorMessages[Err.NOT_BZIP_DATA] = "Not bzip data";
+    ErrorMessages[Err.UNEXPECTED_INPUT_EOF] = "Unexpected input EOF";
+    ErrorMessages[Err.UNEXPECTED_OUTPUT_EOF] = "Unexpected output EOF";
+    ErrorMessages[Err.DATA_ERROR] = "Data error";
+    ErrorMessages[Err.OUT_OF_MEMORY] = "Out of memory";
+    ErrorMessages[Err.OBSOLETE_INPUT] = "Obsolete (pre 0.9.5) bzip format not supported.";
+    var _throw = function(status, optDetail) {
+      var msg = ErrorMessages[status] || "unknown error";
+      if (optDetail) {
+        msg += ": " + optDetail;
+      }
+      var e = new TypeError(msg);
+      e.errorCode = status;
+      throw e;
+    };
+    var Bunzip = function(inputStream, outputStream) {
+      this.writePos = this.writeCurrent = this.writeCount = 0;
+      this._start_bunzip(inputStream, outputStream);
+    };
+    Bunzip.prototype._init_block = function() {
+      var moreBlocks = this._get_next_block();
+      if (!moreBlocks) {
+        this.writeCount = -1;
+        return false;
+      }
+      this.blockCRC = new CRC32();
+      return true;
+    };
+    Bunzip.prototype._start_bunzip = function(inputStream, outputStream) {
+      var buf = new Buffer(4);
+      if (inputStream.read(buf, 0, 4) !== 4 || String.fromCharCode(buf[0], buf[1], buf[2]) !== "BZh")
+        _throw(Err.NOT_BZIP_DATA, "bad magic");
+      var level = buf[3] - 48;
+      if (level < 1 || level > 9)
+        _throw(Err.NOT_BZIP_DATA, "level out of range");
+      this.reader = new BitReader(inputStream);
+      this.dbufSize = 1e5 * level;
+      this.nextoutput = 0;
+      this.outputStream = outputStream;
+      this.streamCRC = 0;
+    };
+    Bunzip.prototype._get_next_block = function() {
+      var i, j, k;
+      var reader = this.reader;
+      var h = reader.pi();
+      if (h === SQRTPI) {
+        return false;
+      }
+      if (h !== WHOLEPI)
+        _throw(Err.NOT_BZIP_DATA);
+      this.targetBlockCRC = reader.read(32) >>> 0;
+      this.streamCRC = (this.targetBlockCRC ^ (this.streamCRC << 1 | this.streamCRC >>> 31)) >>> 0;
+      if (reader.read(1))
+        _throw(Err.OBSOLETE_INPUT);
+      var origPointer = reader.read(24);
+      if (origPointer > this.dbufSize)
+        _throw(Err.DATA_ERROR, "initial position out of bounds");
+      var t = reader.read(16);
+      var symToByte = new Buffer(256), symTotal = 0;
+      for (i = 0; i < 16; i++) {
+        if (t & 1 << 15 - i) {
+          var o = i * 16;
+          k = reader.read(16);
+          for (j = 0; j < 16; j++)
+            if (k & 1 << 15 - j)
+              symToByte[symTotal++] = o + j;
+        }
+      }
+      var groupCount = reader.read(3);
+      if (groupCount < MIN_GROUPS || groupCount > MAX_GROUPS)
+        _throw(Err.DATA_ERROR);
+      var nSelectors = reader.read(15);
+      if (nSelectors === 0)
+        _throw(Err.DATA_ERROR);
+      var mtfSymbol = new Buffer(256);
+      for (i = 0; i < groupCount; i++)
+        mtfSymbol[i] = i;
+      var selectors = new Buffer(nSelectors);
+      for (i = 0; i < nSelectors; i++) {
+        for (j = 0; reader.read(1); j++)
+          if (j >= groupCount) _throw(Err.DATA_ERROR);
+        selectors[i] = mtf(mtfSymbol, j);
+      }
+      var symCount = symTotal + 2;
+      var groups = [], hufGroup;
+      for (j = 0; j < groupCount; j++) {
+        var length = new Buffer(symCount), temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
+        t = reader.read(5);
+        for (i = 0; i < symCount; i++) {
+          for (; ; ) {
+            if (t < 1 || t > MAX_HUFCODE_BITS) _throw(Err.DATA_ERROR);
+            if (!reader.read(1))
+              break;
+            if (!reader.read(1))
+              t++;
+            else
+              t--;
+          }
+          length[i] = t;
+        }
+        var minLen, maxLen;
+        minLen = maxLen = length[0];
+        for (i = 1; i < symCount; i++) {
+          if (length[i] > maxLen)
+            maxLen = length[i];
+          else if (length[i] < minLen)
+            minLen = length[i];
+        }
+        hufGroup = {};
+        groups.push(hufGroup);
+        hufGroup.permute = new Uint16Array(MAX_SYMBOLS);
+        hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 2);
+        hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);
+        hufGroup.minLen = minLen;
+        hufGroup.maxLen = maxLen;
+        var pp = 0;
+        for (i = minLen; i <= maxLen; i++) {
+          temp[i] = hufGroup.limit[i] = 0;
+          for (t = 0; t < symCount; t++)
+            if (length[t] === i)
+              hufGroup.permute[pp++] = t;
+        }
+        for (i = 0; i < symCount; i++)
+          temp[length[i]]++;
+        pp = t = 0;
+        for (i = minLen; i < maxLen; i++) {
+          pp += temp[i];
+          hufGroup.limit[i] = pp - 1;
+          pp <<= 1;
+          t += temp[i];
+          hufGroup.base[i + 1] = pp - t;
+        }
+        hufGroup.limit[maxLen + 1] = Number.MAX_VALUE;
+        hufGroup.limit[maxLen] = pp + temp[maxLen] - 1;
+        hufGroup.base[minLen] = 0;
+      }
+      var byteCount = new Uint32Array(256);
+      for (i = 0; i < 256; i++)
+        mtfSymbol[i] = i;
+      var runPos = 0, dbufCount = 0, selector = 0, uc;
+      var dbuf = this.dbuf = new Uint32Array(this.dbufSize);
+      symCount = 0;
+      for (; ; ) {
+        if (!symCount--) {
+          symCount = GROUP_SIZE - 1;
+          if (selector >= nSelectors) {
+            _throw(Err.DATA_ERROR);
+          }
+          hufGroup = groups[selectors[selector++]];
+        }
+        i = hufGroup.minLen;
+        j = reader.read(i);
+        for (; ; i++) {
+          if (i > hufGroup.maxLen) {
+            _throw(Err.DATA_ERROR);
+          }
+          if (j <= hufGroup.limit[i])
+            break;
+          j = j << 1 | reader.read(1);
+        }
+        j -= hufGroup.base[i];
+        if (j < 0 || j >= MAX_SYMBOLS) {
+          _throw(Err.DATA_ERROR);
+        }
+        var nextSym = hufGroup.permute[j];
+        if (nextSym === SYMBOL_RUNA || nextSym === SYMBOL_RUNB) {
+          if (!runPos) {
+            runPos = 1;
+            t = 0;
+          }
+          if (nextSym === SYMBOL_RUNA)
+            t += runPos;
+          else
+            t += 2 * runPos;
+          runPos <<= 1;
+          continue;
+        }
+        if (runPos) {
+          runPos = 0;
+          if (dbufCount + t > this.dbufSize) {
+            _throw(Err.DATA_ERROR);
+          }
+          uc = symToByte[mtfSymbol[0]];
+          byteCount[uc] += t;
+          while (t--)
+            dbuf[dbufCount++] = uc;
+        }
+        if (nextSym > symTotal)
+          break;
+        if (dbufCount >= this.dbufSize) {
+          _throw(Err.DATA_ERROR);
+        }
+        i = nextSym - 1;
+        uc = mtf(mtfSymbol, i);
+        uc = symToByte[uc];
+        byteCount[uc]++;
+        dbuf[dbufCount++] = uc;
+      }
+      if (origPointer < 0 || origPointer >= dbufCount) {
+        _throw(Err.DATA_ERROR);
+      }
+      j = 0;
+      for (i = 0; i < 256; i++) {
+        k = j + byteCount[i];
+        byteCount[i] = j;
+        j = k;
+      }
+      for (i = 0; i < dbufCount; i++) {
+        uc = dbuf[i] & 255;
+        dbuf[byteCount[uc]] |= i << 8;
+        byteCount[uc]++;
+      }
+      var pos = 0, current = 0, run = 0;
+      if (dbufCount) {
+        pos = dbuf[origPointer];
+        current = pos & 255;
+        pos >>= 8;
+        run = -1;
+      }
+      this.writePos = pos;
+      this.writeCurrent = current;
+      this.writeCount = dbufCount;
+      this.writeRun = run;
+      return true;
+    };
+    Bunzip.prototype._read_bunzip = function(outputBuffer, len) {
+      var copies, previous, outbyte;
+      if (this.writeCount < 0) {
+        return 0;
+      }
+      var gotcount = 0;
+      var dbuf = this.dbuf, pos = this.writePos, current = this.writeCurrent;
+      var dbufCount = this.writeCount, outputsize = this.outputsize;
+      var run = this.writeRun;
+      while (dbufCount) {
+        dbufCount--;
+        previous = current;
+        pos = dbuf[pos];
+        current = pos & 255;
+        pos >>= 8;
+        if (run++ === 3) {
+          copies = current;
+          outbyte = previous;
+          current = -1;
+        } else {
+          copies = 1;
+          outbyte = current;
+        }
+        this.blockCRC.updateCRCRun(outbyte, copies);
+        while (copies--) {
+          this.outputStream.writeByte(outbyte);
+          this.nextoutput++;
+        }
+        if (current != previous)
+          run = 0;
+      }
+      this.writeCount = dbufCount;
+      if (this.blockCRC.getCRC() !== this.targetBlockCRC) {
+        _throw(Err.DATA_ERROR, "Bad block CRC (got " + this.blockCRC.getCRC().toString(16) + " expected " + this.targetBlockCRC.toString(16) + ")");
+      }
+      return this.nextoutput;
+    };
+    var coerceInputStream = function(input) {
+      if ("readByte" in input) {
+        return input;
+      }
+      var inputStream = new Stream();
+      inputStream.pos = 0;
+      inputStream.readByte = function() {
+        return input[this.pos++];
+      };
+      inputStream.seek = function(pos) {
+        this.pos = pos;
+      };
+      inputStream.eof = function() {
+        return this.pos >= input.length;
+      };
+      return inputStream;
+    };
+    var coerceOutputStream = function(output) {
+      var outputStream = new Stream();
+      var resizeOk = true;
+      if (output) {
+        if (typeof output === "number") {
+          outputStream.buffer = new Buffer(output);
+          resizeOk = false;
+        } else if ("writeByte" in output) {
+          return output;
+        } else {
+          outputStream.buffer = output;
+          resizeOk = false;
+        }
+      } else {
+        outputStream.buffer = new Buffer(16384);
+      }
+      outputStream.pos = 0;
+      outputStream.writeByte = function(_byte) {
+        if (resizeOk && this.pos >= this.buffer.length) {
+          var newBuffer = new Buffer(this.buffer.length * 2);
+          this.buffer.copy(newBuffer);
+          this.buffer = newBuffer;
+        }
+        this.buffer[this.pos++] = _byte;
+      };
+      outputStream.getBuffer = function() {
+        if (this.pos !== this.buffer.length) {
+          if (!resizeOk)
+            throw new TypeError("outputsize does not match decoded input");
+          var newBuffer = new Buffer(this.pos);
+          this.buffer.copy(newBuffer, 0, 0, this.pos);
+          this.buffer = newBuffer;
+        }
+        return this.buffer;
+      };
+      outputStream._coerced = true;
+      return outputStream;
+    };
+    Bunzip.Err = Err;
+    Bunzip.decode = function(input, output, multistream) {
+      var inputStream = coerceInputStream(input);
+      var outputStream = coerceOutputStream(output);
+      var bz = new Bunzip(inputStream, outputStream);
+      while (true) {
+        if ("eof" in inputStream && inputStream.eof()) break;
+        if (bz._init_block()) {
+          bz._read_bunzip();
+        } else {
+          var targetStreamCRC = bz.reader.read(32) >>> 0;
+          if (targetStreamCRC !== bz.streamCRC) {
+            _throw(Err.DATA_ERROR, "Bad stream CRC (got " + bz.streamCRC.toString(16) + " expected " + targetStreamCRC.toString(16) + ")");
+          }
+          if (multistream && "eof" in inputStream && !inputStream.eof()) {
+            bz._start_bunzip(inputStream, outputStream);
+          } else break;
+        }
+      }
+      if ("getBuffer" in outputStream)
+        return outputStream.getBuffer();
+    };
+    Bunzip.decodeBlock = function(input, pos, output) {
+      var inputStream = coerceInputStream(input);
+      var outputStream = coerceOutputStream(output);
+      var bz = new Bunzip(inputStream, outputStream);
+      bz.reader.seek(pos);
+      var moreBlocks = bz._get_next_block();
+      if (moreBlocks) {
+        bz.blockCRC = new CRC32();
+        bz.writeCopies = 0;
+        bz._read_bunzip();
+      }
+      if ("getBuffer" in outputStream)
+        return outputStream.getBuffer();
+    };
+    Bunzip.table = function(input, callback, multistream) {
+      var inputStream = new Stream();
+      inputStream.delegate = coerceInputStream(input);
+      inputStream.pos = 0;
+      inputStream.readByte = function() {
+        this.pos++;
+        return this.delegate.readByte();
+      };
+      if (inputStream.delegate.eof) {
+        inputStream.eof = inputStream.delegate.eof.bind(inputStream.delegate);
+      }
+      var outputStream = new Stream();
+      outputStream.pos = 0;
+      outputStream.writeByte = function() {
+        this.pos++;
+      };
+      var bz = new Bunzip(inputStream, outputStream);
+      var blockSize = bz.dbufSize;
+      while (true) {
+        if ("eof" in inputStream && inputStream.eof()) break;
+        var position = inputStream.pos * 8 + bz.reader.bitOffset;
+        if (bz.reader.hasByte) {
+          position -= 8;
+        }
+        if (bz._init_block()) {
+          var start = outputStream.pos;
+          bz._read_bunzip();
+          callback(position, outputStream.pos - start);
+        } else {
+          var crc = bz.reader.read(32);
+          if (multistream && "eof" in inputStream && !inputStream.eof()) {
+            bz._start_bunzip(inputStream, outputStream);
+            console.assert(
+              bz.dbufSize === blockSize,
+              "shouldn't change block size within multistream file"
+            );
+          } else break;
+        }
+      }
+    };
+    Bunzip.Stream = Stream;
+    Bunzip.version = pjson.version;
+    Bunzip.license = pjson.license;
+    module.exports = Bunzip;
+  }
+});
+
+// src/nexrad/radarArchiveCore.ts
+var import_buffer = __toESM(require_buffer(), 1);
+var bzip = __toESM(require_lib(), 1);
+
+// src/nexrad/nexradLevel3Products.ts
+import {
+  clampNexradTiltForVariable,
+  formatTiltForApi,
+  getDefaultRadarTilt,
+  getRadarTilts,
+  isTerminalRadar
+} from "@aguacerowx/javascript-sdk";
+var NEXRAD_LEVEL3_MENU = [
+  {
+    radarKey: "VEL",
+    product: "N0G",
+    menuLabel: "Storm Relative Velocity",
+    fldKey: "nexrad_vel",
+    cmapPropertyKey: "nexrad_vel",
+    decodeMode: "velocity",
+    stormRelativeVelocity: true
+  },
+  {
+    radarKey: "KDP",
+    product: "N0K",
+    menuLabel: "Specific Differential Phase",
+    fldKey: "nexrad_l3_n0k",
+    cmapPropertyKey: "nexrad_kdp",
+    defaultUnit: "deg/km",
+    decodeMode: "generic_physical"
+  },
+  {
+    radarKey: "N0H",
+    product: "N0H",
+    menuLabel: "Hydrometeor Classification",
+    fldKey: "nexrad_l3_n0h",
+    cmapPropertyKey: "nexrad_l3_n0h",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "HHC",
+    product: "HHC",
+    menuLabel: "Hybrid Hydrometeor Classification",
+    fldKey: "nexrad_l3_hhc",
+    cmapPropertyKey: "nexrad_l3_hhc",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "EET",
+    product: "EET",
+    menuLabel: "Enhanced Echo Tops",
+    fldKey: "nexrad_l3_eet",
+    cmapPropertyKey: "nexrad_l3_eet",
+    defaultUnit: "kft",
+    decodeMode: "tops_kft"
+  },
+  {
+    radarKey: "DVL",
+    product: "DVL",
+    menuLabel: "Vertically Integrated Liquid",
+    fldKey: "nexrad_l3_dvl",
+    cmapPropertyKey: "nexrad_l3_dvl",
+    defaultUnit: "kg/m\xB2",
+    decodeMode: "vil"
+  },
+  {
+    radarKey: "DAA",
+    product: "DAA",
+    menuLabel: "1-Hour Precipitation",
+    fldKey: "nexrad_l3_daa",
+    cmapPropertyKey: "tp_0_1",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DU3",
+    product: "DU3",
+    menuLabel: "3-Hour Precipitation",
+    fldKey: "nexrad_l3_du3",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DTA",
+    product: "DTA",
+    menuLabel: "Storm Total Precipitation",
+    fldKey: "nexrad_l3_dta",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  }
+];
+var byRadarKey = /* @__PURE__ */ new Map();
+for (const e of NEXRAD_LEVEL3_MENU) {
+  byRadarKey.set(e.radarKey, e);
+  if (e.radarKey === "DVL") byRadarKey.set("NVL", e);
+}
+function getNexradLevel3EntryByRadarKey(radarKey) {
+  return byRadarKey.get(radarKey);
+}
+var NEXRAD_LEVEL3_KDP_PRODUCTS = [
+  "NXK",
+  "NYK",
+  "NZK",
+  "N0K",
+  "NAK",
+  "N1K",
+  "NBK",
+  "N2K",
+  "N3K"
+];
+var NEXRAD_LEVEL3_DHC_PRODUCTS = [
+  "NXH",
+  "NYH",
+  "NZH",
+  "N0H",
+  "NAH",
+  "N1H",
+  "NBH",
+  "N2H",
+  "N3H"
+];
+var NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_KDP_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_DHC_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_MANIFEST_TILT_COUNT = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST.length;
+function level3EetHeightKmFromLevel(level, dataMaskRaw, scaleRaw, offsetRaw) {
+  if (level < 2) return null;
+  const masked = level & (dataMaskRaw & 65535);
+  if (!Number.isFinite(scaleRaw) || scaleRaw === 0) {
+    return level - 2;
+  }
+  const mapped = (masked - offsetRaw) / scaleRaw;
+  if (!Number.isFinite(mapped)) return null;
+  return mapped;
+}
+function level3ValuePacking(decodeMode) {
+  switch (decodeMode) {
+    case "velocity":
+      return { valueScale: 0.01, valueOffset: 0 };
+    case "dbz":
+      return { valueScale: 0.5, valueOffset: -32 };
+    case "precip":
+      return { valueScale: 1e-3, valueOffset: 0 };
+    case "categorical":
+      return { valueScale: 1, valueOffset: 0 };
+    case "tops_kft":
+      return { valueScale: 2e-3, valueOffset: 0 };
+    case "vil":
+      return { valueScale: 0.1, valueOffset: 0 };
+    case "generic_physical":
+      return { valueScale: 0.01, valueOffset: 0 };
+    default:
+      return { valueScale: 0.5, valueOffset: -32 };
+  }
+}
+
+// src/nexrad/level3StormRelative.ts
+function parseLevel3StormMotionFromBuffer(buffer) {
+  const bytes = new Uint8Array(buffer);
+  const marker = [83, 68, 85, 83];
+  let start = 0;
+  for (let i = 0; i <= bytes.length - 4; i++) {
+    if (bytes[i] === marker[0] && bytes[i + 1] === marker[1] && bytes[i + 2] === marker[2] && bytes[i + 3] === marker[3]) {
+      start = i;
+      break;
+    }
+  }
+  const dv = new DataView(buffer, start, bytes.length - start);
+  const textLen = 30;
+  const msgHdrLen = 18;
+  const pdbStart = textLen + msgHdrLen;
+  if (pdbStart + 86 > dv.byteLength) return null;
+  if (dv.getInt16(pdbStart, false) !== -1) return null;
+  const dep8Offset = pdbStart + 82;
+  const dep8 = dv.getInt16(dep8Offset, false);
+  const dep9 = dv.getInt16(dep8Offset + 2, false);
+  const stormSpeedKt = dep8 / 10;
+  const speedMs = stormSpeedKt * 0.514444;
+  const directionDeg = dep9 / 10;
+  if (!Number.isFinite(speedMs) || !Number.isFinite(directionDeg)) return null;
+  return { speedMs, directionDeg };
+}
+function level3StormRadialComponentMs(stormSpeedMs, stormDirectionDeg, azimuthDeg) {
+  const stormDirRad = stormDirectionDeg * Math.PI / 180;
+  const azRad = azimuthDeg * Math.PI / 180;
+  return stormSpeedMs * Math.cos(stormDirRad - azRad);
+}
+function decodeGateRawMs(hi, lo, valueScale, valueOffset) {
+  const raw = lo + hi * 256;
+  let signed = raw;
+  if (raw >= 32768) signed = raw - 65536;
+  if (signed <= -32768) return null;
+  return signed * valueScale + valueOffset;
+}
+function encodeGateRawMs(physicalMs, valueScale, valueOffset) {
+  const raw = Math.round((physicalMs - valueOffset) / valueScale);
+  const signed = Math.max(-32768, Math.min(32767, raw));
+  const u = signed < 0 ? signed + 65536 : signed;
+  return [u >> 8 & 255, u & 255];
+}
+function applyLevel3StormRelativeToFrame(frame, stormSpeedMs, stormDirectionDeg) {
+  const { nRays, nGates, gateData, rayBoundariesDeg, valueScale, valueOffset } = frame;
+  const out = new Uint8Array(gateData.length);
+  for (let r = 0; r < nRays; r++) {
+    const azLow = rayBoundariesDeg[r];
+    const azHigh = rayBoundariesDeg[r + 1];
+    const azimuthDeg = (Number(azLow) + Number(azHigh)) * 0.5;
+    const stormComp = level3StormRadialComponentMs(stormSpeedMs, stormDirectionDeg, azimuthDeg);
+    for (let g = 0; g < nGates; g++) {
+      const o = (r * nGates + g) * 2;
+      const hi = gateData[o];
+      const lo = gateData[o + 1];
+      const v = decodeGateRawMs(hi, lo, valueScale, valueOffset);
+      if (v == null) {
+        out[o] = hi;
+        out[o + 1] = lo;
+        continue;
+      }
+      const corrected = v + stormComp;
+      const [nh, nl] = encodeGateRawMs(corrected, valueScale, valueOffset);
+      out[o] = nh;
+      out[o + 1] = nl;
+    }
+  }
+  return { ...frame, gateData: out };
+}
+
+// src/nexrad/nexradArchiveCache.ts
+var MAX_ARCHIVE_CACHE_ENTRIES = 5e3;
+var archiveCache = /* @__PURE__ */ new Map();
+function setArchiveCache(url, archive) {
+  archiveCache.delete(url);
+  archiveCache.set(url, archive);
+  while (archiveCache.size > MAX_ARCHIVE_CACHE_ENTRIES) {
+    const oldestKey = archiveCache.keys().next().value;
+    if (!oldestKey) break;
+    archiveCache.delete(oldestKey);
+  }
+}
+
+// src/nexrad/loadNexradSites.ts
+var sitesUrl = "/data/nexrad.json";
+var nexradSitesPayloadPromise = null;
+function loadNexradSitesPayload() {
+  if (nexradSitesPayloadPromise) {
+    return nexradSitesPayloadPromise;
+  }
+  nexradSitesPayloadPromise = fetch(sitesUrl).then((response) => {
+    if (!response.ok) throw new Error(`nexrad.json fetch failed: HTTP ${response.status}`);
+    return response.json();
+  }).catch((error) => {
+    console.error("[mapsgl] Could not load nexrad.json:", error);
+    nexradSitesPayloadPromise = null;
+    throw error;
+  });
+  return nexradSitesPayloadPromise;
+}
+async function loadNexradSites() {
+  const payload = await loadNexradSitesPayload();
+  if (Array.isArray(payload)) return payload;
+  const sites = payload.sites;
+  if (sites && Array.isArray(sites)) return sites;
+  return [];
+}
+
+// src/nexrad/radarArchiveCore.ts
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = import_buffer.Buffer;
+}
+var NEXRAD_ARCHIVE_API_KEY = "";
+function setNexradArchiveApiKey(k) {
+  NEXRAD_ARCHIVE_API_KEY = k || "";
+}
+function createRadarDecodeWorker() {
+  return new Worker(new URL("./radarDecode.worker.bundled.js", import.meta.url), { type: "module" });
+}
+var LEVEL2_BASE_URL = "https://d3dc62msmxkrd7.cloudfront.net/level-2";
+var LEVEL3_BASE_URL = "https://unidata-nexrad-level3.s3.amazonaws.com";
+var DECODE_WORKER_POOL_SIZE = 2;
+var PREFETCH_WORKER_START_INDEX = 1;
+var inflightFetches = /* @__PURE__ */ new Map();
+var inflightFetchMeta = /* @__PURE__ */ new Map();
+var radarFetchRequestSeq = 0;
+var radarDecodeWorkers = [];
+var radarDecodeRequestId = 0;
+var radarDecodePending = /* @__PURE__ */ new Map();
+var radarDecodeRequestMeta = /* @__PURE__ */ new Map();
+var radarDecodePrefetchWorkerIndex = PREFETCH_WORKER_START_INDEX;
+function createDecodeWorker(workerIndex) {
+  const worker = createRadarDecodeWorker();
+  worker.onmessage = (event) => {
+    const message = event.data;
+    if (!message || message.type !== "DECODE_RESULT") return;
+    const pending = radarDecodePending.get(message.requestId);
+    if (!pending) return;
+    radarDecodePending.delete(message.requestId);
+    radarDecodeRequestMeta.delete(message.requestId);
+    if (message.error) {
+      pending.reject(new Error(message.error));
+      return;
+    }
+    if (!message.gateData || typeof message.nRays !== "number" || typeof message.nGates !== "number" || typeof message.stationLat !== "number" || typeof message.stationLon !== "number" || typeof message.firstGateKm !== "number" || typeof message.gateWidthKm !== "number" || typeof message.valueScale !== "number" || typeof message.valueOffset !== "number" || !(message.rayBoundariesDeg instanceof Float32Array)) {
+      pending.resolve(null);
+      return;
+    }
+    pending.resolve({
+      gateData: message.gateData,
+      nRays: message.nRays,
+      nGates: message.nGates,
+      stationLat: message.stationLat,
+      stationLon: message.stationLon,
+      firstGateKm: message.firstGateKm,
+      gateWidthKm: message.gateWidthKm,
+      valueScale: message.valueScale,
+      valueOffset: message.valueOffset,
+      rayBoundariesDeg: message.rayBoundariesDeg
+    });
+  };
+  worker.onerror = (error) => {
+    radarDecodePending.forEach(({ reject }) => reject(new Error(error.message || "Radar decode worker failed")));
+    radarDecodePending.clear();
+    radarDecodeRequestMeta.clear();
+  };
+  return worker;
+}
+function getRadarDecodeWorkers() {
+  if (radarDecodeWorkers.length > 0) return radarDecodeWorkers;
+  radarDecodeWorkers = Array.from({ length: DECODE_WORKER_POOL_SIZE }, (_, idx) => createDecodeWorker(idx));
+  return radarDecodeWorkers;
+}
+function getDecodeWorkerForPriority(priority) {
+  const workers = getRadarDecodeWorkers();
+  if (priority === "display" || workers.length === 1) {
+    return { worker: workers[0], workerIndex: 0 };
+  }
+  const prefetchWorkerCount = Math.max(workers.length - PREFETCH_WORKER_START_INDEX, 1);
+  const offset = (radarDecodePrefetchWorkerIndex - PREFETCH_WORKER_START_INDEX + prefetchWorkerCount) % prefetchWorkerCount;
+  const workerIndex = PREFETCH_WORKER_START_INDEX + offset;
+  radarDecodePrefetchWorkerIndex = PREFETCH_WORKER_START_INDEX + (offset + 1) % prefetchWorkerCount;
+  return { worker: workers[Math.min(workerIndex, workers.length - 1)], workerIndex: Math.min(workerIndex, workers.length - 1) };
+}
+function objectKeyToUrl(objectKey, radarSource = "level2") {
+  if (objectKey.startsWith("http")) return objectKey;
+  const baseUrl = radarSource === "level3" ? LEVEL3_BASE_URL : LEVEL2_BASE_URL;
+  return `${baseUrl.replace(/\/$/, "")}/${objectKey}`;
+}
+var Level3Raf = class {
+  offset = 0;
+  view;
+  bytes;
+  constructor(input) {
+    this.bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+  }
+  getPos() {
+    return this.offset;
+  }
+  getLength() {
+    return this.bytes.length;
+  }
+  seek(pos) {
+    this.offset = pos;
+  }
+  skip(delta) {
+    this.offset += delta;
+  }
+  read(bytes = 1) {
+    const out = this.bytes.subarray(this.offset, this.offset + bytes);
+    this.offset += bytes;
+    return out;
+  }
+  readByte() {
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  readShort() {
+    const v = this.view.getInt16(this.offset, false);
+    this.offset += 2;
+    return v;
+  }
+  readUShort() {
+    const v = this.view.getUint16(this.offset, false);
+    this.offset += 2;
+    return v;
+  }
+  readInt() {
+    const v = this.view.getInt32(this.offset, false);
+    this.offset += 4;
+    return v;
+  }
+  readUInt32() {
+    const v = this.view.getUint32(this.offset, false);
+    this.offset += 4;
+    return v;
+  }
+  readString(bytes) {
+    const slice = this.read(bytes);
+    return String.fromCharCode(...slice);
+  }
+};
+function concatUint8(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+var LEVEL3_PRODUCT_RANGE_SCALE_MUL = {
+  19: 1,
+  20: 2,
+  25: 0.25,
+  27: 1,
+  28: 0.25,
+  30: 1,
+  32: 1,
+  34: 1,
+  56: 1,
+  57: 1e3,
+  78: 1,
+  79: 1,
+  80: 1,
+  94: 1,
+  99: 0.25,
+  134: 1e3,
+  135: 1e3,
+  138: 1,
+  153: 0.25,
+  154: 0.25,
+  155: 0.25,
+  159: 0.25,
+  161: 0.25,
+  163: 0.25,
+  165: 0.25,
+  166: 0.25,
+  167: 0.25,
+  168: 0.25,
+  169: 1e3,
+  170: 1e3,
+  171: 1e3,
+  172: 1e3,
+  173: 1e3,
+  174: 1e3,
+  175: 1e3,
+  /** Py-ART `PRODUCT_RANGE_RESOLUTION`: 176/177 are digital-style radials (0.25×), not 1 km like 169–175. */
+  176: 0.25,
+  177: 0.25,
+  181: 150,
+  182: 150,
+  186: 300
+};
+var LEVEL3_GENERIC_DIGITAL_PRODUCT_CODES = /* @__PURE__ */ new Set([
+  159,
+  161,
+  163,
+  167,
+  168,
+  170,
+  172,
+  173,
+  174,
+  175,
+  176
+]);
+var LEVEL3_GENERIC_DIGITAL_DEPTH_MM_TO_IN_PRODUCTS = /* @__PURE__ */ new Set([170, 172, 173, 174, 175]);
+var LEVEL3_DIGITAL_HMC_PRODUCT_CODES = /* @__PURE__ */ new Set([165, 177]);
+function level3PhysicalFromDigitalHmc(level, precision) {
+  if (!Number.isFinite(level)) return null;
+  if (precision === "nibble") {
+    if (level < 2 || level > 15) return null;
+    return level - 2;
+  }
+  if (level === 150) return null;
+  if (level < 10 || level >= 256) return null;
+  const cls = Math.floor(level / 10) - 1;
+  if (cls < 0 || cls > 11) return null;
+  return cls;
+}
+function level3GenericDigitalAccumMmFactor(productCode) {
+  switch (productCode) {
+    case 170:
+      return 0.125;
+    case 172:
+    case 173:
+    case 174:
+    case 175:
+      return 0.25;
+    default:
+      return 1;
+  }
+}
+function level3UnpackFloat32FromThresholdPair(short0, short1) {
+  const buf = new ArrayBuffer(4);
+  const view = new DataView(buf);
+  view.setUint16(0, short0 & 65535, false);
+  view.setUint16(2, short1 & 65535, false);
+  return view.getFloat32(0, false);
+}
+function parseLevel3GenericDigitalParams(dep) {
+  if (dep.length < 9) return null;
+  const scale = level3UnpackFloat32FromThresholdPair(dep[1], dep[2]);
+  const offset = level3UnpackFloat32FromThresholdPair(dep[3], dep[4]);
+  const maxDataVal = dep[6] & 65535;
+  const leadingFlags = dep[7];
+  const trailingFlags = dep[8];
+  if (!Number.isFinite(scale) || scale === 0 || !Number.isFinite(offset)) return null;
+  if (leadingFlags < 0 || leadingFlags > 255 || trailingFlags < 0 || trailingFlags > 255) return null;
+  if (maxDataVal < leadingFlags) return null;
+  return { scale, offset, leadingFlags, trailingFlags, maxDataVal };
+}
+function level3PhysicalFromGenericDigital(level, p, productCode) {
+  if (!Number.isFinite(level)) return null;
+  if (level < p.leadingFlags) return null;
+  const upper = p.maxDataVal - p.trailingFlags;
+  if (level > upper) return null;
+  let out = (level - p.offset) / p.scale;
+  if (!Number.isFinite(out)) return null;
+  if (LEVEL3_GENERIC_DIGITAL_DEPTH_MM_TO_IN_PRODUCTS.has(productCode)) {
+    out *= level3GenericDigitalAccumMmFactor(productCode);
+    out /= 25.4;
+  }
+  return out;
+}
+function level3PhysicalFromDataLevel(level, minimumDataValue, dataIncrement, mode, msg134Params) {
+  if (!Number.isFinite(level)) return null;
+  if (mode === "digital_velocity_byte") {
+    if (level < 2) return null;
+    return minimumDataValue + (level - 2) * dataIncrement;
+  }
+  if (mode === "digital_velocity_rle4") {
+    if (level < 2) return null;
+    const MS_PER_STEP = 4;
+    const CENTER_LEVEL = 8;
+    return (level - CENTER_LEVEL) * MS_PER_STEP;
+  }
+  if (msg134Params) {
+    if (level < 2) return null;
+    const { linearScale, linearOffset, logStart, logScale, logOffset } = msg134Params;
+    if (level < logStart) {
+      return (level - linearOffset) / linearScale;
+    } else {
+      return Math.exp((level - logOffset) / logScale);
+    }
+  }
+  if (mode === "standard_digital") {
+    if (level < 2) return null;
+    return minimumDataValue + (level - 2) * dataIncrement;
+  }
+  if (level <= 1) return null;
+  return minimumDataValue + level * dataIncrement;
+}
+function parseLevel3Packet0010(raf, minimumDataValue, dataIncrement, levelMode, l3ProductCode, msg134Params, eetThresholds, genericDigital) {
+  const packetCode = raf.readUShort();
+  if (packetCode !== 16) throw new Error(`Unexpected packet code ${packetCode}`);
+  const firstBinMeters = raf.readShort();
+  let numberBins = raf.readShort();
+  raf.readShort();
+  raf.readShort();
+  const rangeScaleRaw = raf.readShort();
+  const numberRadials = raf.readShort();
+  if (numberRadials > 0) {
+    const peek = raf.getPos();
+    const nbytesFirst = raf.readShort();
+    raf.seek(peek);
+    if (nbytesFirst !== numberBins) {
+      numberBins = nbytesFirst;
+    }
+  }
+  const radials = [];
+  for (let r = 0; r < numberRadials; r++) {
+    const bytesInRadial = raf.readShort();
+    const startAngle = raf.readShort() / 10;
+    const angleDelta = raf.readShort() / 10;
+    const bins = [];
+    for (let i = 0; i < numberBins; i++) {
+      const level = raf.readByte();
+      if (eetThresholds) {
+        bins.push(
+          level3EetHeightKmFromLevel(level, eetThresholds.dataMask, eetThresholds.scale, eetThresholds.offset)
+        );
+      } else if (LEVEL3_DIGITAL_HMC_PRODUCT_CODES.has(l3ProductCode)) {
+        bins.push(level3PhysicalFromDigitalHmc(level, "byte"));
+      } else if (genericDigital) {
+        bins.push(level3PhysicalFromGenericDigital(level, genericDigital, l3ProductCode));
+      } else {
+        bins.push(level3PhysicalFromDataLevel(level, minimumDataValue, dataIncrement, levelMode, msg134Params));
+      }
+    }
+    if (bytesInRadial > numberBins) raf.skip(bytesInRadial - numberBins);
+    radials.push({ startAngle, angleDelta, bins });
+  }
+  return { firstBinMeters, numberBins, rangeScaleRaw, numberRadials, radials };
+}
+function parseLevel3PacketAF1F(raf, minimumDataValue, dataIncrement, levelMode, l3ProductCode, msg134Params, eetThresholds, genericDigital) {
+  const packetCode = raf.readUShort();
+  if (packetCode !== 44831) throw new Error(`Unexpected packet code ${packetCode}`);
+  const firstBinMeters = raf.readShort();
+  const numberBins = raf.readShort();
+  raf.readShort();
+  raf.readShort();
+  const rangeScaleRaw = raf.readShort();
+  const numRadials = raf.readShort();
+  const radials = [];
+  for (let r = 0; r < numRadials; r++) {
+    const rleBytes = raf.readShort() * 2;
+    const startAngle = raf.readShort() / 10;
+    const angleDelta = raf.readShort() / 10;
+    const bins = [];
+    for (let i = 0; i < rleBytes; i++) {
+      const byte = raf.readByte();
+      const run = byte >> 4;
+      const level = byte & 15;
+      const value = eetThresholds ? level3EetHeightKmFromLevel(level, eetThresholds.dataMask, eetThresholds.scale, eetThresholds.offset) : LEVEL3_DIGITAL_HMC_PRODUCT_CODES.has(l3ProductCode) ? level3PhysicalFromDigitalHmc(level, "nibble") : genericDigital ? level3PhysicalFromGenericDigital(level, genericDigital, l3ProductCode) : level3PhysicalFromDataLevel(level, minimumDataValue, dataIncrement, levelMode, msg134Params);
+      for (let j = 0; j < run; j++) bins.push(value);
+    }
+    if (bins.length > numberBins) bins.length = numberBins;
+    while (bins.length < numberBins) bins.push(null);
+    radials.push({ startAngle, angleDelta, bins });
+  }
+  return { firstBinMeters, numberBins, rangeScaleRaw, numberRadials: numRadials, radials };
+}
+function buildRayBoundariesFromLevel3Radials(radials) {
+  const n = radials.length;
+  const boundaries = new Float32Array(n + 1);
+  let prev = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const startAngle = Number(radials[i]?.startAngle);
+    const angleDelta = Number(radials[i]?.angleDelta);
+    const start = Number.isFinite(startAngle) ? startAngle : 0;
+    const delta = Number.isFinite(angleDelta) && angleDelta > 0 ? angleDelta : 1;
+    let lower = start - delta * 0.5;
+    while (lower <= prev) lower += 360;
+    boundaries[i] = lower;
+    prev = lower;
+  }
+  const lastDeltaRaw = Number(radials[n - 1]?.angleDelta);
+  const lastDelta = Number.isFinite(lastDeltaRaw) && lastDeltaRaw > 0 ? lastDeltaRaw : 1;
+  boundaries[n] = boundaries[n - 1] + lastDelta;
+  return boundaries;
+}
+function encodeSigned16ToHiLo(value) {
+  const signed = Math.max(-32768, Math.min(32767, value));
+  const raw = signed < 0 ? signed + 65536 : signed;
+  return [raw >> 8 & 255, raw & 255];
+}
+function level3RadialSpatialScore(p) {
+  if (!p) return -1;
+  const nb = Number(p.numberBins);
+  const nr = Number(p.numberRadials);
+  if (!Number.isFinite(nb) || !Number.isFinite(nr) || nb <= 0 || nr <= 0) return -1;
+  return nb * nr;
+}
+function level3RadialPickIsBetter(cand, prev) {
+  const sC = level3RadialSpatialScore(cand.packet);
+  const sP = level3RadialSpatialScore(prev?.packet);
+  if (sC > sP) return true;
+  if (sC < sP) return false;
+  if (!prev) return true;
+  if (cand.kind === 16 && prev.kind === 44831) return true;
+  return false;
+}
+function trySkipLevel3OverlayPacket(raf, packetCode, layerEnd) {
+  const pos0 = raf.getPos();
+  if (packetCode !== 1 && packetCode !== 2 && packetCode !== 8) return false;
+  if (layerEnd - pos0 < 4) return false;
+  const codeRead = raf.readUShort();
+  if (codeRead !== packetCode) {
+    raf.seek(pos0);
+    return false;
+  }
+  const payloadBytes = raf.readUShort();
+  if (payloadBytes > layerEnd - raf.getPos()) {
+    raf.seek(pos0);
+    return false;
+  }
+  raf.skip(payloadBytes);
+  return true;
+}
+var LEVEL3_PACKET_RASTER_BA07 = 47623;
+var LEVEL3_RASTER_INNER_CODE = 2147483840;
+function unpackLevel3RasterRle(rowBytes) {
+  const unpacked = [];
+  for (let i = 0; i < rowBytes.length; i++) {
+    const b = rowBytes[i];
+    const run = b >> 4;
+    const val = b & 15;
+    for (let j = 0; j < run; j++) unpacked.push(val);
+  }
+  return unpacked;
+}
+function level3CombineRasterScale(int16, frac16) {
+  const i = Math.abs(int16);
+  const f = Math.abs(frac16) / 1e4;
+  const s = i + f;
+  return s > 0 ? s : 1;
+}
+function parseLevel3PacketRasterBA07(raf, layerEnd, objectKey) {
+  const pos0 = raf.getPos();
+  const packetCode = raf.readUShort();
+  if (packetCode !== LEVEL3_PACKET_RASTER_BA07) {
+    raf.seek(pos0);
+    return null;
+  }
+  const room = layerEnd - raf.getPos();
+  if (room < 20) {
+    raf.seek(layerEnd);
+    return null;
+  }
+  const inner = raf.readUInt32();
+  if (inner !== LEVEL3_RASTER_INNER_CODE) {
+    raf.seek(layerEnd);
+    return null;
+  }
+  const iStart = raf.readShort();
+  const jStart = raf.readShort();
+  const xscaleInt = raf.readShort();
+  const xscaleFrac = raf.readShort();
+  const yscaleInt = raf.readShort();
+  const yscaleFrac = raf.readShort();
+  const numRows = raf.readUShort();
+  const packing = raf.readUShort();
+  if (packing !== 2) {
+    console.warn("[aguacero][nexrad-l3][raster-ba07-packing]", { objectKey, packing, hint: "MetPy expects packing=2; raster parse skipped for this layer" });
+    raf.seek(layerEnd);
+    return null;
+  }
+  if (numRows <= 0 || numRows > 2e3 || raf.getPos() > layerEnd) {
+    raf.seek(layerEnd);
+    return null;
+  }
+  const cellKmX = level3CombineRasterScale(xscaleInt, xscaleFrac);
+  const cellKmY = level3CombineRasterScale(yscaleInt, yscaleFrac);
+  const startXKm = iStart * xscaleInt;
+  const startYKm = jStart * yscaleInt;
+  const rows = [];
+  let nCols = -1;
+  for (let r = 0; r < numRows; r++) {
+    if (raf.getPos() + 2 > layerEnd) {
+      raf.seek(layerEnd);
+      return null;
+    }
+    const rowNumBytes = raf.readUShort();
+    if (rowNumBytes === 0 || raf.getPos() + rowNumBytes > layerEnd) {
+      raf.seek(layerEnd);
+      return null;
+    }
+    const rowBytes = raf.read(rowNumBytes);
+    const expanded = unpackLevel3RasterRle(rowBytes);
+    if (nCols < 0) nCols = expanded.length;
+    else if (expanded.length !== nCols) {
+      raf.seek(layerEnd);
+      return null;
+    }
+    rows.push(expanded);
+  }
+  if (nCols <= 0) {
+    raf.seek(layerEnd);
+    return null;
+  }
+  if (raf.getPos() < layerEnd) {
+    raf.seek(layerEnd);
+  }
+  return {
+    iStart,
+    jStart,
+    cellKmX,
+    cellKmY,
+    startXKm,
+    startYKm,
+    nCols,
+    nRows: numRows,
+    rows
+  };
+}
+function level3RasterPdbScales(decodeMode, productCode, minimumDataValue, dataIncrement, depProductDescriptionShorts, objectKey, genericDigital) {
+  const minBad = !Number.isFinite(minimumDataValue) || Math.abs(minimumDataValue) > 500;
+  const incBad = !Number.isFinite(dataIncrement) || dataIncrement <= 0;
+  const bad = minBad || incBad;
+  let minT = minimumDataValue;
+  let dataInc = dataIncrement;
+  let vilLevelThresholds = null;
+  if (decodeMode === "vil" && productCode === 57 && Array.isArray(depProductDescriptionShorts) && depProductDescriptionShorts.length >= 17 && depProductDescriptionShorts[1] <= -3e4) {
+    const byLevel = new Array(16).fill(Number.NaN);
+    let validCount = 0;
+    for (let level = 2; level <= 15; level++) {
+      const raw = depProductDescriptionShorts[level + 1];
+      if (Number.isFinite(raw) && raw > 0) {
+        byLevel[level] = raw;
+        validCount += 1;
+      }
+    }
+    if (validCount >= 8) {
+      vilLevelThresholds = byLevel;
+    }
+  }
+  if (bad) {
+    if (decodeMode === "vil" && minBad && !incBad && dataIncrement >= 0.05 && dataIncrement <= 2) {
+      minT = -dataIncrement;
+      dataInc = dataIncrement;
+    } else if (decodeMode === "vil") {
+      minT = 0;
+      dataInc = 1;
+    } else if (decodeMode === "precip") {
+      minT = 0;
+      dataInc = 0.25;
+    } else if (decodeMode === "tops_kft") {
+      minT = 0;
+      dataInc = 1;
+    } else if (decodeMode === "categorical") {
+      minT = 0;
+      dataInc = 1;
+    } else if (decodeMode === "generic_physical") {
+      minT = -2;
+      dataInc = 0.05;
+    } else {
+      minT = -32;
+      dataInc = 0.5;
+    }
+  }
+  const symMode = decodeMode === "velocity" ? "digital_velocity_byte" : decodeMode === "precip" && !genericDigital ? "standard_digital" : "reflectivity";
+  return { minT, dataInc, symMode, vilLevelThresholds };
+}
+function level3RasterToPolarFrame(raster, stationLat, stationLon, decodeMode, minT, dataInc, symMode, vilLevelThresholds, eetThresholds, valueScale, valueOffset, objectKey, genericDigital = null, l3ProductCode = 0) {
+  const { rows, nCols, nRows, startXKm, startYKm, cellKmX, cellKmY, iStart, jStart } = raster;
+  const widthKm = nCols * cellKmX;
+  const heightKm = nRows * cellKmY;
+  let originXK = startXKm;
+  let originYK = startYKm;
+  if (iStart === 0 && jStart === 0 && nCols === nRows && nCols >= 16) {
+    originXK = startXKm - widthKm / 2;
+    originYK = startYKm - heightKm / 2;
+  }
+  const xMin = originXK;
+  const xMax = originXK + widthKm;
+  const yMin = originYK;
+  const yMax = originYK + heightKm;
+  const corner = (x, y) => Math.hypot(x, y);
+  let maxR = corner(xMin, yMin);
+  maxR = Math.max(maxR, corner(xMax, yMin));
+  maxR = Math.max(maxR, corner(xMin, yMax));
+  maxR = Math.max(maxR, corner(xMax, yMax));
+  maxR = Math.min(460, Math.max(50, maxR * 1.02));
+  const nRays = 720;
+  const gateWidthKm = 0.5;
+  const nGates = Math.min(920, Math.max(64, Math.ceil(maxR / gateWidthKm)));
+  const firstGateKm = 0;
+  const gateData = new Uint8Array(nRays * nGates * 2);
+  const rayBoundariesDeg = new Float32Array(nRays + 1);
+  const deltaAz = 360 / nRays;
+  for (let i = 0; i <= nRays; i++) {
+    rayBoundariesDeg[i] = i * deltaAz - deltaAz * 0.5;
+  }
+  let samples = 0;
+  let nodata = 0;
+  for (let rayIdx = 0; rayIdx < nRays; rayIdx++) {
+    const azDeg = (rayIdx + 0.5) * deltaAz;
+    const azRad = azDeg * Math.PI / 180;
+    const sinAz = Math.sin(azRad);
+    const cosAz = Math.cos(azRad);
+    for (let g = 0; g < nGates; g++) {
+      const rKm = firstGateKm + (g + 0.5) * gateWidthKm;
+      const xKm = rKm * sinAz;
+      const yKm = rKm * cosAz;
+      const fc = (xKm - originXK) / cellKmX;
+      const fr = (yKm - originYK) / cellKmY;
+      const c = Math.floor(fc);
+      const r = Math.floor(fr);
+      let level = null;
+      if (c >= 0 && c < nCols && r >= 0 && r < nRows) {
+        level = rows[r][c] ?? null;
+      }
+      let phys = null;
+      if (level != null && Number.isFinite(level)) {
+        if (decodeMode === "vil" && vilLevelThresholds && level >= 0 && level < vilLevelThresholds.length && Number.isFinite(vilLevelThresholds[level])) {
+          phys = vilLevelThresholds[level];
+        } else if (decodeMode === "tops_kft" && eetThresholds) {
+          phys = level3EetHeightKmFromLevel(
+            level,
+            eetThresholds.dataMask,
+            eetThresholds.scale,
+            eetThresholds.offset
+          );
+        } else if (LEVEL3_DIGITAL_HMC_PRODUCT_CODES.has(l3ProductCode)) {
+          phys = level3PhysicalFromDigitalHmc(level, "nibble");
+        } else if (genericDigital) {
+          phys = level3PhysicalFromGenericDigital(level, genericDigital, l3ProductCode);
+        } else {
+          phys = level3PhysicalFromDataLevel(level, minT, dataInc, symMode);
+        }
+      }
+      if (phys == null || !Number.isFinite(phys)) {
+        nodata++;
+        const offset2 = (rayIdx * nGates + g) * 2;
+        gateData[offset2] = 128;
+        gateData[offset2 + 1] = 0;
+        continue;
+      }
+      samples++;
+      const rawSigned = Math.round((phys - valueOffset) / valueScale);
+      const [hi, lo] = encodeSigned16ToHiLo(rawSigned);
+      const offset = (rayIdx * nGates + g) * 2;
+      gateData[offset] = hi;
+      gateData[offset + 1] = lo;
+    }
+  }
+  if (samples < 8) {
+    console.warn("[aguacero][nexrad-l3][raster-nearly-empty]", { objectKey, samples, nodata });
+    return null;
+  }
+  return {
+    gateData,
+    nRays,
+    nGates,
+    stationLat,
+    stationLon,
+    firstGateKm,
+    gateWidthKm,
+    valueScale,
+    valueOffset,
+    rayBoundariesDeg
+  };
+}
+function isValidLevel3PdbStart(bytes, pos) {
+  const len = bytes.length;
+  if (pos + 14 > len) return false;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const latLonPlausible = (latMilli, lonMilli) => {
+    const lat = latMilli / 1e3;
+    const lon = lonMilli / 1e3;
+    return lat >= -60 && lat <= 72 && lon >= -180 && lon <= 180 && Math.abs(lat) > 1 && Math.abs(lon) > 1;
+  };
+  if (bytes[pos] === 255 && bytes[pos + 1] === 255) {
+    const latMilli = view.getInt32(pos + 2, false);
+    const lonMilli = view.getInt32(pos + 6, false);
+    return latLonPlausible(latMilli, lonMilli);
+  }
+  if (pos + 28 <= len) {
+    const productCode = view.getUint16(pos, false);
+    const divider = view.getInt16(pos + 18, false);
+    if (productCode >= 1 && productCode <= 499 && divider === -1) {
+      const latMilli = view.getInt32(pos + 20, false);
+      const lonMilli = view.getInt32(pos + 24, false);
+      if (latLonPlausible(latMilli, lonMilli)) return true;
+    }
+  }
+  return false;
+}
+function findLevel3PdbByteOffset(bytes) {
+  const len = bytes.length;
+  let pos = 0;
+  while (pos < len) {
+    let lineEnd = pos;
+    while (lineEnd < len && bytes[lineEnd] !== 10 && bytes[lineEnd] !== 13) lineEnd++;
+    while (lineEnd < len && (bytes[lineEnd] === 10 || bytes[lineEnd] === 13)) lineEnd++;
+    const nextStart = lineEnd;
+    if (nextStart >= len - 2) break;
+    if (isValidLevel3PdbStart(bytes, nextStart)) return nextStart;
+    pos = nextStart;
+  }
+  if (len < 30) return 30;
+  const end = Math.min(len - 14, 900);
+  for (let i = 16; i <= end; i++) {
+    if (isValidLevel3PdbStart(bytes, i)) return i;
+  }
+  return 30;
+}
+function decodeLevel3RasterProduct(buffer, objectKey, radarVariable) {
+  try {
+    const bytes = new Uint8Array(buffer);
+    const marker = [83, 68, 85, 83];
+    let startIndex = 0;
+    for (let i = 0; i <= bytes.length - marker.length; i++) {
+      if (bytes[i] === marker[0] && bytes[i + 1] === marker[1] && bytes[i + 2] === marker[2] && bytes[i + 3] === marker[3]) {
+        startIndex = i;
+        break;
+      }
+    }
+    const trimmed = startIndex > 0 ? bytes.subarray(startIndex) : bytes;
+    const raf = new Level3Raf(trimmed);
+    const fileType = raf.readString(6);
+    if (!fileType.startsWith("SDUS")) {
+      throw new Error(`Unexpected Level3 header ${fileType}`);
+    }
+    const pdbByteOffset = findLevel3PdbByteOffset(trimmed);
+    raf.seek(pdbByteOffset);
+    const headerWord0 = raf.readShort();
+    let stationLat;
+    let stationLon;
+    let productCode;
+    if (headerWord0 === -1) {
+      stationLat = raf.readInt() / 1e3;
+      stationLon = raf.readInt() / 1e3;
+      raf.readShort();
+      productCode = raf.readUShort();
+    } else {
+      raf.seek(pdbByteOffset);
+      productCode = raf.readUShort();
+      raf.readShort();
+      raf.readInt();
+      raf.readInt();
+      raf.readShort();
+      raf.readShort();
+      raf.readShort();
+      const divider = raf.readShort();
+      if (divider !== -1) throw new Error(`Invalid product divider ${divider}`);
+      stationLat = raf.readInt() / 1e3;
+      stationLon = raf.readInt() / 1e3;
+      raf.readShort();
+      raf.readShort();
+    }
+    raf.readShort();
+    raf.readShort();
+    raf.readShort();
+    raf.readShort();
+    raf.readShort();
+    raf.readInt();
+    raf.readShort();
+    raf.readInt();
+    raf.read(4);
+    raf.readShort();
+    const dep30_53 = new Level3Raf(raf.read(48));
+    const depProductDescriptionShorts = [];
+    for (let i = 0; i < 24; i++) {
+      depProductDescriptionShorts.push(dep30_53.readShort());
+    }
+    const minimumDataValue = depProductDescriptionShorts[1] / 10;
+    const dataIncrement = depProductDescriptionShorts[2] / 10;
+    const compressionMethod = depProductDescriptionShorts[21];
+    const genericDigitalParams = LEVEL3_GENERIC_DIGITAL_PRODUCT_CODES.has(productCode) ? parseLevel3GenericDigitalParams(depProductDescriptionShorts) : null;
+    if (LEVEL3_GENERIC_DIGITAL_PRODUCT_CODES.has(productCode) && !genericDigitalParams) {
+      console.warn("[aguacero][nexrad-l3][generic-digital-params-null]", {
+        objectKey,
+        radarVariable,
+        productCode,
+        depHead: depProductDescriptionShorts.slice(0, 12),
+        hint: "Continuing with legacy min/inc; precip values may be wrong \xE2\u20AC\u201D check dep alignment / PDB offset."
+      });
+    }
+    let msg134Params = null;
+    if (productCode === 134 && depProductDescriptionShorts.length >= 6) {
+      const hw31 = depProductDescriptionShorts[1];
+      const hw32 = depProductDescriptionShorts[2];
+      const hw33 = depProductDescriptionShorts[3];
+      const hw34 = depProductDescriptionShorts[4];
+      const hw35 = depProductDescriptionShorts[5];
+      msg134Params = {
+        linearScale: int16ToFloat16(hw31),
+        linearOffset: int16ToFloat16(hw32),
+        logStart: hw33,
+        logScale: int16ToFloat16(hw34),
+        logOffset: int16ToFloat16(hw35)
+      };
+    }
+    const l3Entry = getNexradLevel3EntryByRadarKey(radarVariable);
+    const decodeMode = l3Entry?.decodeMode ?? (radarVariable === "VEL" || radarVariable === "N0G" || radarVariable === "SW" || radarVariable === "N0W" ? "velocity" : "dbz");
+    const isVelSw = decodeMode === "velocity";
+    let minThreshold = minimumDataValue;
+    let dataInc = dataIncrement;
+    if (isVelSw) {
+      const pdbLooksInvalid = !Number.isFinite(dataInc) || dataInc <= 0 || dataInc > 25 || !Number.isFinite(minThreshold) || Math.abs(minThreshold) > 130;
+      if (pdbLooksInvalid) {
+        minThreshold = -63.5;
+        dataInc = 0.5;
+      }
+    }
+    if (decodeMode === "precip" && productCode === 138) {
+      dataInc = depProductDescriptionShorts[2] * 0.01;
+    }
+    const eetRadialThresholds = decodeMode === "tops_kft" && productCode === 135 ? {
+      dataMask: depProductDescriptionShorts[1],
+      scale: depProductDescriptionShorts[2],
+      offset: depProductDescriptionShorts[3]
+    } : null;
+    raf.readByte();
+    raf.readByte();
+    const offsetSymbology = raf.readInt();
+    raf.readInt();
+    raf.readInt();
+    let parseBytes = trimmed;
+    if (compressionMethod > 0) {
+      const headerBytes = trimmed.subarray(0, raf.getPos());
+      const compressedTail = trimmed.subarray(raf.getPos());
+      const decompressedTail = bzip.decode(compressedTail);
+      parseBytes = concatUint8(headerBytes, decompressedTail);
+    }
+    const parseRaf = new Level3Raf(parseBytes);
+    const symbologyOffsetBytes = pdbByteOffset + offsetSymbology * 2;
+    parseRaf.seek(symbologyOffsetBytes);
+    const blockDivider = parseRaf.readShort();
+    const blockId = parseRaf.readShort();
+    if (blockDivider !== -1 || blockId !== 1) {
+      const oob = symbologyOffsetBytes < 0 || symbologyOffsetBytes >= parseBytes.length;
+      console.warn("[aguacero][nexrad-l3][symbology-header-bad]", {
+        objectKey,
+        radarVariable,
+        productCode,
+        blockDivider,
+        blockId,
+        symbologyOffsetBytes,
+        parseBytesLength: parseBytes.length,
+        seekOob: oob,
+        hint: "Usually wrong PDB byte offset; check [sym-offset] and findLevel3PdbByteOffset."
+      });
+      throw new Error(`Invalid symbology header ${blockDivider}/${blockId}`);
+    }
+    parseRaf.readInt();
+    const numberLayers = parseRaf.readShort();
+    let bestRadial = null;
+    let rasterParsed = null;
+    const symbologyPacketCodes = [];
+    for (let layerIndex = 0; layerIndex < numberLayers; layerIndex++) {
+      const layerStart = parseRaf.getPos();
+      const layerDivider = parseRaf.readShort();
+      const layerPayloadLength = parseRaf.readInt();
+      if (layerDivider !== -1) {
+        parseRaf.seek(layerStart + 6 + layerPayloadLength);
+        continue;
+      }
+      const layerEnd = parseRaf.getPos() + layerPayloadLength;
+      while (parseRaf.getPos() < layerEnd) {
+        const packetPos = parseRaf.getPos();
+        const packetCode = parseRaf.readUShort();
+        symbologyPacketCodes.push(packetCode);
+        parseRaf.seek(packetPos);
+        if (packetCode === 16) {
+          const symMode = isVelSw ? "digital_velocity_byte" : decodeMode === "precip" && !genericDigitalParams ? "standard_digital" : "reflectivity";
+          const p = parseLevel3Packet0010(
+            parseRaf,
+            minThreshold,
+            dataInc,
+            symMode,
+            productCode,
+            msg134Params,
+            eetRadialThresholds,
+            genericDigitalParams
+          );
+          const cand = { kind: 16, packet: p };
+          if (level3RadialPickIsBetter(cand, bestRadial)) bestRadial = cand;
+          continue;
+        }
+        if (packetCode === 44831) {
+          const symMode = isVelSw ? "digital_velocity_rle4" : decodeMode === "precip" && !genericDigitalParams ? "standard_digital" : "reflectivity";
+          const p = parseLevel3PacketAF1F(
+            parseRaf,
+            minThreshold,
+            dataInc,
+            symMode,
+            productCode,
+            msg134Params,
+            eetRadialThresholds,
+            genericDigitalParams
+          );
+          const cand = { kind: 44831, packet: p };
+          if (level3RadialPickIsBetter(cand, bestRadial)) bestRadial = cand;
+          continue;
+        }
+        if (packetCode === LEVEL3_PACKET_RASTER_BA07) {
+          parseRaf.seek(packetPos);
+          const parsed = parseLevel3PacketRasterBA07(parseRaf, layerEnd, objectKey);
+          if (parsed && rasterParsed === null) rasterParsed = parsed;
+          else if (!parsed) parseRaf.seek(layerEnd);
+          continue;
+        }
+        if (trySkipLevel3OverlayPacket(parseRaf, packetCode, layerEnd)) {
+          continue;
+        }
+        parseRaf.seek(layerEnd);
+        break;
+      }
+      parseRaf.seek(layerEnd);
+    }
+    const shouldPreferRaster = rasterParsed != null && (decodeMode === "tops_kft" && productCode !== 135 || decodeMode === "precip");
+    if (bestRadial && !shouldPreferRaster) {
+      const radialPacket = bestRadial.packet;
+      const radials = radialPacket?.radials;
+      const nRays = Number(radialPacket?.numberRadials);
+      const nGates = Number(radialPacket?.numberBins);
+      if (!Array.isArray(radials) || !Number.isFinite(nRays) || !Number.isFinite(nGates) || !Number.isFinite(stationLat) || !Number.isFinite(stationLon)) {
+        console.warn("[aguacero][nexrad-l3][invalid-radial-packet]", { objectKey, radarVariable, nRays, nGates, stationLat, stationLon });
+      } else {
+        const gateData = new Uint8Array(nRays * nGates * 2);
+        const { valueScale, valueOffset } = level3ValuePacking(decodeMode);
+        for (let r = 0; r < nRays; r++) {
+          const bins = radials[r]?.bins;
+          for (let g = 0; g < nGates; g++) {
+            const v = bins?.[g];
+            const isNoData = v == null || !Number.isFinite(v);
+            const rawSigned = isNoData ? -32768 : Math.round((Number(v) - valueOffset) / valueScale);
+            const [hi, lo] = encodeSigned16ToHiLo(rawSigned);
+            const offset = (r * nGates + g) * 2;
+            gateData[offset] = hi;
+            gateData[offset + 1] = lo;
+          }
+        }
+        const rangeMul = LEVEL3_PRODUCT_RANGE_SCALE_MUL[productCode] ?? 1;
+        const rangeScaleRaw = Number(radialPacket?.rangeScaleRaw);
+        const gateSpacingM = Number.isFinite(rangeScaleRaw) && rangeScaleRaw > 0 ? rangeScaleRaw * rangeMul : 250;
+        let gateWidthKm = gateSpacingM / 1e3;
+        const firstBinM = Number(radialPacket?.firstBinMeters);
+        let firstGateKm = Number.isFinite(firstBinM) && firstBinM >= 0 ? firstBinM / 1e3 : 0;
+        const decodedCoverageKm = firstGateKm + nGates * gateWidthKm;
+        if (decodedCoverageKm > 0 && decodedCoverageKm < 20 && nGates >= 100) {
+          gateWidthKm *= 1e3;
+          firstGateKm *= 1e3;
+        }
+        if (decodeMode === "precip" && decodedCoverageKm > 1500) {
+          gateWidthKm /= 1e3;
+          firstGateKm /= 1e3;
+        }
+        const rayBoundariesDeg = buildRayBoundariesFromLevel3Radials(radials);
+        return {
+          gateData,
+          nRays,
+          nGates,
+          stationLat,
+          stationLon,
+          firstGateKm,
+          gateWidthKm,
+          valueScale,
+          valueOffset,
+          rayBoundariesDeg
+        };
+      }
+    }
+    if (rasterParsed) {
+      const { valueScale, valueOffset } = level3ValuePacking(decodeMode);
+      const { minT, dataInc: rasterDataInc, symMode, vilLevelThresholds } = level3RasterPdbScales(
+        decodeMode,
+        productCode,
+        minThreshold,
+        dataInc,
+        depProductDescriptionShorts,
+        objectKey,
+        genericDigitalParams
+      );
+      const eetThresholds = decodeMode === "tops_kft" && productCode === 135 ? {
+        dataMask: depProductDescriptionShorts[1],
+        scale: depProductDescriptionShorts[2],
+        offset: depProductDescriptionShorts[3]
+      } : null;
+      const rasterFrame = level3RasterToPolarFrame(
+        rasterParsed,
+        stationLat,
+        stationLon,
+        decodeMode,
+        minT,
+        rasterDataInc,
+        symMode,
+        vilLevelThresholds,
+        eetThresholds,
+        valueScale,
+        valueOffset,
+        objectKey,
+        genericDigitalParams,
+        productCode
+      );
+      if (rasterFrame) {
+        return rasterFrame;
+      }
+    }
+    const hex = symbologyPacketCodes.map((c) => `0x${c.toString(16)}`);
+    if (!bestRadial) {
+      console.warn("[aguacero][nexrad-l3][no-radial-symbology]", {
+        objectKey,
+        radarVariable,
+        messageCode: productCode,
+        numberLayers,
+        symbologyPacketCodes,
+        symbologyPacketCodesHex: hex,
+        hint: "Radial: packets 0x10 / 0xAF1F. Raster: 0xBA07 is supported; if rasterParsed failed, check parseLevel3PacketRasterBA07 / inner code logs."
+      });
+    }
+    return null;
+  } catch (err) {
+    console.warn("[aguacero][nexrad-l3][decode-throw]", { objectKey, radarVariable, err });
+    return null;
+  }
+}
+var GROUP2_VARS = ["VEL", "SW"];
+var GROUP1_VARS = ["REF", "ZDR", "RHO", "PHI"];
+var GROUP2_COMBINED_7_VARS = ["REF", "ZDR", "RHO", "PHI", "KDP", "VEL", "SW"];
+var GROUP2_COMBINED_VARS = ["REF", "ZDR", "RHO", "PHI", "VEL", "SW"];
+var FILE_HDR_BYTES = 64;
+var AZ_BLOCK_BYTES = 720 * 4;
+var SLOT_INDEX_ENTRY = 18;
+var MAX_SLOTS = 6;
+function int16ToFloat16(val) {
+  const sign = (val & 32768) / 32768;
+  const exponent = (val & 31744) / 1024;
+  const fraction = val & 1023;
+  if (exponent === 0) {
+    return Math.pow(-1, sign) * 2 * (0 + fraction / Math.pow(2, 10));
+  }
+  return Math.pow(-1, sign) * Math.pow(2, exponent - 16) * (1 + fraction / Math.pow(2, 10));
+}
+function parseFileHeader(buffer) {
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, false);
+  if (magic !== 1314406980) throw new Error(`Bad magic: 0x${magic.toString(16)}`);
+  const unixTime = view.getUint32(4, false);
+  const nRays = view.getUint16(8, false);
+  const nGates = view.getUint16(10, false);
+  const elevAngle = view.getFloat32(12, false);
+  const firstGateKm = view.getFloat32(16, false);
+  const gateWidthKm = view.getFloat32(20, false);
+  const nSlots = view.getUint16(24, false);
+  const azimuthsBuffer = buffer.slice(FILE_HDR_BYTES, FILE_HDR_BYTES + AZ_BLOCK_BYTES);
+  const idxStart = FILE_HDR_BYTES + AZ_BLOCK_BYTES;
+  const slots = [];
+  for (let i = 0; i < nSlots; i++) {
+    const base = idxStart + i * SLOT_INDEX_ENTRY;
+    const offsetHigh = view.getUint32(base, false);
+    const offsetLow = view.getUint32(base + 4, false);
+    const offset = offsetHigh * 2 ** 32 + offsetLow;
+    const compressedSize = view.getUint32(base + 8, false);
+    const uncompressedSize = view.getUint32(base + 12, false);
+    slots.push({ offset, compressedSize, uncompressedSize });
+  }
+  return {
+    unixTime,
+    nRays,
+    nGates,
+    elevAngle,
+    firstGateKm,
+    gateWidthKm,
+    nSlots,
+    azimuthsBuffer,
+    slots
+  };
+}
+function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, signal) {
+  if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  const { worker } = getDecodeWorkerForPriority(priority);
+  const requestId = ++radarDecodeRequestId;
+  const azCopy = header.azimuthsBuffer.slice(0);
+  return new Promise((resolve, reject) => {
+    let isSettled = false;
+    const onAbort = () => {
+      if (isSettled) return;
+      isSettled = true;
+      radarDecodePending.delete(requestId);
+      radarDecodeRequestMeta.delete(requestId);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    radarDecodePending.set(requestId, {
+      resolve: (frame) => {
+        if (!isSettled) {
+          isSettled = true;
+          signal?.removeEventListener("abort", onAbort);
+          resolve(frame);
+        }
+      },
+      reject: (err) => {
+        if (!isSettled) {
+          isSettled = true;
+          signal?.removeEventListener("abort", onAbort);
+          reject(err);
+        }
+      }
+    });
+    if (signal) signal.addEventListener("abort", onAbort, { once: true });
+    worker.postMessage({
+      type: "DECODE_SLOT",
+      requestId,
+      objectKey,
+      slotBuffer,
+      nRays: header.nRays,
+      nGates: header.nGates,
+      firstGateKm: header.firstGateKm,
+      gateWidthKm: header.gateWidthKm,
+      azimuthsBuffer: azCopy,
+      sites
+    }, [slotBuffer, azCopy]);
+  });
+}
+async function applyStormMotionFromN0sObjectKey(frame, motionObjectKey, logLabel) {
+  const motionUrl = objectKeyToUrl(motionObjectKey, "level3");
+  try {
+    const motionResp = await fetch(motionUrl);
+    if (motionResp.ok) {
+      const motionBuf = await motionResp.arrayBuffer();
+      const motion = parseLevel3StormMotionFromBuffer(motionBuf);
+      if (motion) {
+        return applyLevel3StormRelativeToFrame(frame, motion.speedMs, motion.directionDeg);
+      }
+    }
+  } catch (e) {
+    console.log(`${logLabel}:srvMotionFetchError`, { motionObjectKey, err: e });
+  }
+  return frame;
+}
+async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, radarSource, options) {
+  const mot = options?.level3MotionObjectKey ? `|${options.level3MotionObjectKey}` : "";
+  const cacheKey = `${url}:${radarVariable}:${radarSource}${mot}`;
+  const priority = options?.priority ?? "display";
+  if (archiveCache.has(cacheKey)) {
+    const cached = archiveCache.get(cacheKey);
+    setArchiveCache(cacheKey, cached);
+    return cached;
+  }
+  const existingInflight = inflightFetches.get(cacheKey);
+  if (existingInflight) {
+    const meta = inflightFetchMeta.get(cacheKey);
+    if (meta) {
+      meta.callers += 1;
+    }
+    return existingInflight;
+  }
+  if (options?.signal?.aborted) {
+    return null;
+  }
+  const requestId = ++radarFetchRequestSeq;
+  const startedAt = performance.now();
+  inflightFetchMeta.set(cacheKey, {
+    requestId,
+    startedAt,
+    callers: 1,
+    objectKey,
+    radarVariable,
+    radarSource,
+    priority
+  });
+  const promise = (async () => {
+    try {
+      if (radarSource === "level3") {
+        const response = await fetch(url);
+        if (!response.ok) throw new Error(`HTTP ${response.status} fetching level3 ${url}`);
+        const buffer = await response.arrayBuffer();
+        let decoded2 = decodeLevel3RasterProduct(buffer, objectKey, radarVariable);
+        const motionKey = options?.level3MotionObjectKey;
+        if (decoded2 && motionKey && radarVariable === "VEL") {
+          decoded2 = await applyStormMotionFromN0sObjectKey(
+            decoded2,
+            motionKey,
+            "fetchAndParseArchive:level3"
+          );
+        }
+        if (!decoded2) {
+          console.warn("[aguacero][nexrad-l3][fetch-ok-decode-null]", {
+            objectKey,
+            radarVariable,
+            byteLength: buffer.byteLength,
+            filterConsole: "Also check [aguacero][nexrad-l3][no-radial-symbology] or decode catch logs"
+          });
+        } else {
+          setArchiveCache(cacheKey, decoded2);
+        }
+        return decoded2;
+      }
+      const INDEX_FETCH_BYTES = FILE_HDR_BYTES + AZ_BLOCK_BYTES + MAX_SLOTS * SLOT_INDEX_ENTRY;
+      const indexResp = await fetch(url, {
+        headers: {
+          "x-api-key": NEXRAD_ARCHIVE_API_KEY,
+          "Range": `bytes=0-${INDEX_FETCH_BYTES - 1}`
+        }
+      });
+      if (!indexResp.ok && indexResp.status !== 206) {
+        throw new Error(`HTTP ${indexResp.status} fetching level2 index ${url}`);
+      }
+      const indexBuffer = await indexResp.arrayBuffer();
+      const header = parseFileHeader(indexBuffer);
+      let varList;
+      if (groupId === 2 && header.nSlots === 7) {
+        varList = GROUP2_COMBINED_7_VARS;
+      } else if (groupId === 2 && header.nSlots === 6) {
+        varList = GROUP2_COMBINED_VARS;
+      } else if (groupId === 2) {
+        varList = GROUP2_VARS;
+      } else {
+        varList = [...GROUP1_VARS];
+      }
+      const slotIdx = varList.indexOf(radarVariable);
+      if (slotIdx < 0 || slotIdx >= header.slots.length) {
+        console.warn(`[RadarLayer] ${radarVariable} not in group ${groupId} (nSlots=${header.nSlots})`);
+        setArchiveCache(cacheKey, null);
+        return null;
+      }
+      const slot = header.slots[slotIdx];
+      if (slot.compressedSize === 0) {
+        console.warn(`[RadarLayer] ${radarVariable} slot ${slotIdx} has compressedSize=0`);
+        setArchiveCache(cacheKey, null);
+        return null;
+      }
+      const slotRangeEnd = slot.offset + slot.compressedSize - 1;
+      const slotResp = await fetch(url, {
+        headers: {
+          "x-api-key": NEXRAD_ARCHIVE_API_KEY,
+          "Range": `bytes=${slot.offset}-${slotRangeEnd}`
+        }
+      });
+      if (!slotResp.ok && slotResp.status !== 206) {
+        throw new Error(`HTTP ${slotResp.status} fetching level2 slot ${url}`);
+      }
+      const slotBuffer = await slotResp.arrayBuffer();
+      const sites = await loadNexradSites();
+      let decoded = await decodeSweepInWorker(
+        objectKey,
+        slotBuffer,
+        header,
+        sites,
+        options?.priority ?? "display",
+        void 0
+      );
+      if (!decoded) {
+        setArchiveCache(cacheKey, null);
+        return null;
+      }
+      const l2MotionKey = options?.level3MotionObjectKey;
+      if (l2MotionKey && radarVariable === "VEL") {
+        decoded = await applyStormMotionFromN0sObjectKey(
+          decoded,
+          l2MotionKey,
+          "fetchAndParseArchive:level2"
+        );
+      }
+      setArchiveCache(cacheKey, decoded);
+      return decoded;
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        return null;
+      }
+      console.error(`[RadarLayer] fetchAndParseArchive failed for ${objectKey}:`, err);
+      return null;
+    } finally {
+      inflightFetches.delete(cacheKey);
+      inflightFetchMeta.delete(cacheKey);
+    }
+  })();
+  inflightFetches.set(cacheKey, promise);
+  return promise;
+}
+export {
+  fetchAndParseArchive,
+  objectKeyToUrl,
+  setNexradArchiveApiKey
+};
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+buffer/index.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/