@dxos/node-std - npm Package Compare versions

Comparing version 0.8.4-main.1f223c7 to 0.8.4-main.21d9917

dist/lib/browser/chunk-2OGZPQMO.mjs

+import {
+  process
+} from "./chunk-QN6WLX5Z.mjs";
+import {
+  require_buffer
+} from "./chunk-DDIIPJLY.mjs";
+import {
+  __toESM
+} from "./chunk-3QS3WKRC.mjs";
+
+// src/globals.js
+var import_buffer = __toESM(require_buffer(), 1);
+(() => {
+  if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, "global")) {
+    Object.defineProperty(globalThis, "global", {
+      value: globalThis,
+      configurable: true,
+      writable: false,
+      enumerable: true
+    });
+  }
+  if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
+    globalThis.Buffer = import_buffer.Buffer;
+  }
+  if (typeof globalThis !== "undefined" && !globalThis.process) {
+    globalThis.process = process;
+  }
+})();
+//# sourceMappingURL=chunk-2OGZPQMO.mjs.map

dist/lib/browser/chunk-2OGZPQMO.mjs.map

+{
+  "version": 3,
+  "sources": ["../../../src/globals.js"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Buffer } from 'buffer/';\n\nimport { process } from './process';\n\n(() => {\n  // NOTE(Zan): When running in native context `globalThis.global` is an immutable property.\n  // - Socket already polyfills it.\n\n  // Check if `globalThis` is defined and if `global` can be assigned.\n  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, 'global')) {\n    Object.defineProperty(globalThis, 'global', {\n      value: globalThis,\n      configurable: true,\n      writable: false,\n      enumerable: true,\n    });\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.Buffer) {\n    globalThis.Buffer = Buffer;\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.process) {\n    globalThis.process = process;\n  }\n})();\n"],
+  "mappings": ";;;;;;;;;;;AAIA,oBAAuB;CAItB,MAAM;AAKL,MAAI,OAAO,eAAe,eAAe,CAAC,OAAO,yBAAyB,YAAY,QAAQ,GAAG;AAC/F,WAAO,eAAe,YAAY,UAAU;AAAA,MAC1C,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV,YAAY;AAAA,IACd,CAAC;AAAA,EACH;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,QAAQ;AAC3D,eAAW,SAAS;AAAA,EACtB;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,SAAS;AAC5D,eAAW,UAAU;AAAA,EACvB;AACF,GAAG;",
+  "names": []
+}

dist/lib/browser/chunk-DDIIPJLY.mjs

+import {
+  __commonJS
+} from "./chunk-3QS3WKRC.mjs";
+
+// ../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "../../../node_modules/.pnpm/base64-js@1.5.1/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/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "../../../node_modules/.pnpm/ieee754@1.2.1/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/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "../../../node_modules/.pnpm/buffer@6.0.3/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 = Buffer;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer.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(Buffer.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer.isBuffer(this)) return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer.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, Buffer.prototype);
+      return buf;
+    }
+    function Buffer(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);
+    }
+    Buffer.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 Buffer.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 Buffer.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
+      );
+    }
+    Buffer.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer, 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);
+    }
+    Buffer.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer.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, Buffer.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer.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 Buffer.alloc(+length);
+    }
+    Buffer.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer.prototype;
+    };
+    Buffer.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
+      if (!Buffer.isBuffer(a) || !Buffer.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;
+    };
+    Buffer.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;
+      }
+    };
+    Buffer.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 Buffer.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer.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 (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer.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 (Buffer.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;
+        }
+      }
+    }
+    Buffer.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;
+        }
+      }
+    }
+    Buffer.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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);
+    };
+    Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+    Buffer.prototype.equals = function equals(b) {
+      if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer.compare(this, b) === 0;
+    };
+    Buffer.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) {
+      Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
+    }
+    Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer.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 = Buffer.from(val, encoding);
+      }
+      if (Buffer.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;
+    }
+    Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer.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);
+    }
+    Buffer.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;
+        }
+      }
+    };
+    Buffer.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;
+    }
+    Buffer.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, Buffer.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");
+    }
+    Buffer.prototype.readUintLE = Buffer.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;
+    };
+    Buffer.prototype.readUintBE = Buffer.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;
+    };
+    Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      return this[offset];
+    };
+    Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    };
+    Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    };
+    Buffer.prototype.readUint32LE = Buffer.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;
+    };
+    Buffer.prototype.readUint32BE = Buffer.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]);
+    };
+    Buffer.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));
+    });
+    Buffer.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);
+    });
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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];
+    };
+    Buffer.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);
+    });
+    Buffer.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);
+    });
+    Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer.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 (!Buffer.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");
+    }
+    Buffer.prototype.writeUintLE = Buffer.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;
+    };
+    Buffer.prototype.writeUintBE = Buffer.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;
+    };
+    Buffer.prototype.writeUint8 = Buffer.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;
+    };
+    Buffer.prototype.writeUint16LE = Buffer.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;
+    };
+    Buffer.prototype.writeUint16BE = Buffer.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;
+    };
+    Buffer.prototype.writeUint32LE = Buffer.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;
+    };
+    Buffer.prototype.writeUint32BE = Buffer.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;
+    }
+    Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.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;
+    };
+    Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer.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;
+    }
+    Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    };
+    Buffer.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;
+    }
+    Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    };
+    Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    };
+    Buffer.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer.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;
+    };
+    Buffer.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" && !Buffer.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 = Buffer.isBuffer(val) ? val : Buffer.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");
+    }
+  }
+});
+
+export {
+  require_buffer
+};
+/*! 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
+   *)
+*/
+//# sourceMappingURL=chunk-DDIIPJLY.mjs.map

dist/lib/browser/chunk-QN6WLX5Z.mjs

+// src/process.js
+function nextTick(fun, ...args) {
+  if (args.length > 0) {
+    queueMicrotask(() => fun(...args));
+  } else {
+    queueMicrotask(fun);
+  }
+}
+var title = "browser";
+var platform = "browser";
+var browser = true;
+var env = {};
+var argv = [];
+var version = "";
+var versions = {};
+var release = {};
+var config = {};
+function noop() {
+}
+var on = noop;
+var addListener = noop;
+var once = noop;
+var off = noop;
+var removeListener = noop;
+var removeAllListeners = noop;
+var emit = noop;
+function binding(name) {
+  throw new Error("process.binding is not supported");
+}
+function cwd() {
+  return "/";
+}
+function chdir(dir) {
+  throw new Error("process.chdir is not supported");
+}
+function umask() {
+  return 0;
+}
+var performance = globalThis.performance || {};
+var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
+  return (/* @__PURE__ */ new Date()).getTime();
+};
+function hrtime(previousTimestamp) {
+  var clocktime = performanceNow.call(performance) * 1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [seconds, nanoseconds];
+}
+hrtime.bigint = function() {
+  var clocktime = performanceNow.call(performance) * 1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  return BigInt(seconds * 1e9) + BigInt(nanoseconds);
+};
+var startTime = /* @__PURE__ */ new Date();
+function uptime() {
+  var currentTime = /* @__PURE__ */ new Date();
+  var dif = currentTime - startTime;
+  return dif / 1e3;
+}
+var process = {
+  nextTick,
+  title,
+  browser,
+  env,
+  argv,
+  version,
+  versions,
+  on,
+  addListener,
+  once,
+  off,
+  removeListener,
+  removeAllListeners,
+  emit,
+  binding,
+  cwd,
+  chdir,
+  umask,
+  hrtime,
+  platform,
+  release,
+  config,
+  uptime
+};
+var defines = {};
+Object.keys(defines).forEach((key) => {
+  const segs = key.split(".");
+  let target = process;
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    if (i === segs.length - 1) {
+      target[seg] = defines[key];
+    } else {
+      target = target[seg] || (target[seg] = {});
+    }
+  }
+});
+
+export {
+  process
+};
+//# sourceMappingURL=chunk-QN6WLX5Z.mjs.map

dist/lib/browser/chunk-QN6WLX5Z.mjs.map

+{
+  "version": 3,
+  "sources": ["../../../src/process.js"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\n// !!! Duplicated in @dxos/esbuild-plugins\n// TODO(dmaretskyi): Unify.\n\n// shim for using process in browser\n// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\n/* eslint-disable */\n\nfunction nextTick(fun, ...args) {\n  if (args.length > 0) {\n    queueMicrotask(() => fun(...args));\n  } else {\n    queueMicrotask(fun);\n  }\n}\n\nconst title = 'browser';\nconst platform = 'browser';\nconst browser = true;\nconst env = {};\nconst argv = [];\nconst version = ''; // empty string to avoid regexp issues\nconst versions = {};\nconst release = {};\nconst config = {};\n\nfunction noop() {}\n\nconst on = noop;\nconst addListener = noop;\nconst once = noop;\nconst off = noop;\nconst removeListener = noop;\nconst removeAllListeners = noop;\nconst emit = noop;\n\nfunction binding(name) {\n  throw new Error('process.binding is not supported');\n}\n\nfunction cwd() {\n  return '/';\n}\n\nfunction chdir(dir) {\n  throw new Error('process.chdir is not supported');\n}\n\nfunction umask() {\n  return 0;\n}\n\n// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\nvar performance = globalThis.performance || {};\nvar performanceNow =\n  performance.now ||\n  performance.mozNow ||\n  performance.msNow ||\n  performance.oNow ||\n  performance.webkitNow ||\n  function () {\n    return new Date().getTime();\n  };\n\n// generate timestamp or delta\n// see http://nodejs.org/api/process.html#process_process_hrtime\nfunction hrtime(previousTimestamp) {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  if (previousTimestamp) {\n    seconds = seconds - previousTimestamp[0];\n    nanoseconds = nanoseconds - previousTimestamp[1];\n    if (nanoseconds < 0) {\n      seconds--;\n      nanoseconds += 1e9;\n    }\n  }\n  return [seconds, nanoseconds];\n}\n\nhrtime.bigint = function () {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  return BigInt(seconds * 1e9) + BigInt(nanoseconds);\n};\n\nvar startTime = new Date();\n\nfunction uptime() {\n  var currentTime = new Date();\n  var dif = currentTime - startTime;\n  return dif / 1000;\n}\n\nexport var process = {\n  nextTick: nextTick,\n  title: title,\n  browser: browser,\n  env: env,\n  argv: argv,\n  version: version,\n  versions: versions,\n  on: on,\n  addListener: addListener,\n  once: once,\n  off: off,\n  removeListener: removeListener,\n  removeAllListeners: removeAllListeners,\n  emit: emit,\n  binding: binding,\n  cwd: cwd,\n  chdir: chdir,\n  umask: umask,\n  hrtime: hrtime,\n  platform: platform,\n  release: release,\n  config: config,\n  uptime: uptime,\n};\n\n// replace process.env.VAR with define\n\nconst defines = {};\nObject.keys(defines).forEach((key) => {\n  const segs = key.split('.');\n  let target = process;\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i];\n    if (i === segs.length - 1) {\n      target[seg] = defines[key];\n    } else {\n      target = target[seg] || (target[seg] = {});\n    }\n  }\n});\n"],
+  "mappings": ";AAYA,SAAS,SAAS,QAAQ,MAAM;AAC9B,MAAI,KAAK,SAAS,GAAG;AACnB,mBAAe,MAAM,IAAI,GAAG,IAAI,CAAC;AAAA,EACnC,OAAO;AACL,mBAAe,GAAG;AAAA,EACpB;AACF;AAEA,IAAM,QAAQ;AACd,IAAM,WAAW;AACjB,IAAM,UAAU;AAChB,IAAM,MAAM,CAAC;AACb,IAAM,OAAO,CAAC;AACd,IAAM,UAAU;AAChB,IAAM,WAAW,CAAC;AAClB,IAAM,UAAU,CAAC;AACjB,IAAM,SAAS,CAAC;AAEhB,SAAS,OAAO;AAAC;AAEjB,IAAM,KAAK;AACX,IAAM,cAAc;AACpB,IAAM,OAAO;AACb,IAAM,MAAM;AACZ,IAAM,iBAAiB;AACvB,IAAM,qBAAqB;AAC3B,IAAM,OAAO;AAEb,SAAS,QAAQ,MAAM;AACrB,QAAM,IAAI,MAAM,kCAAkC;AACpD;AAEA,SAAS,MAAM;AACb,SAAO;AACT;AAEA,SAAS,MAAM,KAAK;AAClB,QAAM,IAAI,MAAM,gCAAgC;AAClD;AAEA,SAAS,QAAQ;AACf,SAAO;AACT;AAGA,IAAI,cAAc,WAAW,eAAe,CAAC;AAC7C,IAAI,iBACF,YAAY,OACZ,YAAY,UACZ,YAAY,SACZ,YAAY,QACZ,YAAY,aACZ,WAAY;AACV,UAAO,oBAAI,KAAK,GAAE,QAAQ;AAC5B;AAIF,SAAS,OAAO,mBAAmB;AACjC,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,MAAI,mBAAmB;AACrB,cAAU,UAAU,kBAAkB,CAAC;AACvC,kBAAc,cAAc,kBAAkB,CAAC;AAC/C,QAAI,cAAc,GAAG;AACnB;AACA,qBAAe;AAAA,IACjB;AAAA,EACF;AACA,SAAO,CAAC,SAAS,WAAW;AAC9B;AAEA,OAAO,SAAS,WAAY;AAC1B,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,SAAO,OAAO,UAAU,GAAG,IAAI,OAAO,WAAW;AACnD;AAEA,IAAI,YAAY,oBAAI,KAAK;AAEzB,SAAS,SAAS;AAChB,MAAI,cAAc,oBAAI,KAAK;AAC3B,MAAI,MAAM,cAAc;AACxB,SAAO,MAAM;AACf;AAEO,IAAI,UAAU;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIA,IAAM,UAAU,CAAC;AACjB,OAAO,KAAK,OAAO,EAAE,QAAQ,CAAC,QAAQ;AACpC,QAAM,OAAO,IAAI,MAAM,GAAG;AAC1B,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,MAAM,KAAK,SAAS,GAAG;AACzB,aAAO,GAAG,IAAI,QAAQ,GAAG;AAAA,IAC3B,OAAO;AACL,eAAS,OAAO,GAAG,MAAM,OAAO,GAAG,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

dist/lib/browser/process.mjs

+import {
+  process
+} from "./chunk-QN6WLX5Z.mjs";
+import "./chunk-3QS3WKRC.mjs";
+export {
+  process
+};
+//# sourceMappingURL=process.mjs.map

dist/lib/browser/process.mjs.map

+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

src/node/assert.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:assert';
+export { default } from 'node:assert';

src/node/buffer.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:buffer';
+export { default } from 'node:buffer';

src/node/crypto.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:crypto';
+export { default } from 'node:crypto';

src/node/events.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:events';
+export { default } from 'node:events';

src/node/fs.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:fs';
+export { default } from 'node:fs';

src/node/fs/promises.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:fs/promises';

src/node/globals.js

+//
+// Copyright 2024 DXOS.org
+//
+
+// No-op for node - globals are already available.

src/node/inject-globals.js

+//
+// Copyright 2022 DXOS.org
+//
+
+// To be used with esbuild's inject option.
+// In Node.js, these globals are already available, so we just re-export them.
+
+import { Buffer } from 'node:buffer';
+import process from 'node:process';
+
+const global = globalThis;
+
+export { global, Buffer, process };

src/node/path.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:path';
+export { default } from 'node:path';

src/node/process.js

+//
+// Copyright 2023 DXOS.org
+//
+
+import process from 'node:process';
+
+export { process };

src/node/stream.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:stream';
+export { default } from 'node:stream';

src/node/util.js

+//
+// Copyright 2023 DXOS.org
+//
+
+export * from 'node:util';
+export { default } from 'node:util';

dist/lib/browser/buffer.mjs

 import {
   require_buffer
-} from "./chunk-YERYCS33.mjs";
+} from "./chunk-DDIIPJLY.mjs";
 import {
@@ -5,0 +5,0 @@ __toESM

dist/lib/browser/globals.mjs

@@ -1,5 +0,5 @@
-import "./chunk-LJ5EWKWX.mjs";
-import "./chunk-WA6DPORN.mjs";
-import "./chunk-YERYCS33.mjs";
+import "./chunk-2OGZPQMO.mjs";
+import "./chunk-QN6WLX5Z.mjs";
+import "./chunk-DDIIPJLY.mjs";
 import "./chunk-3QS3WKRC.mjs";
 //# sourceMappingURL=globals.mjs.map

dist/lib/browser/inject-globals.mjs

 import {
   process
-} from "./chunk-WA6DPORN.mjs";
+} from "./chunk-QN6WLX5Z.mjs";
 import {
   require_buffer
-} from "./chunk-YERYCS33.mjs";
+} from "./chunk-DDIIPJLY.mjs";
 import {
@@ -8,0 +8,0 @@ __toESM

dist/lib/browser/meta.json

@@ -1,1 +0,1 @@
-{"inputs":{"src/_/config.js":{"bytes":237,"imports":[],"format":"esm"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytes":1922,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytes":189,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"has-symbols/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytes":67,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytes":66,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytes":121,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytes":214,"imports":[{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js","kind":"require-call","original":"./isNaN"}],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js","kind":"require-call","original":"./gOPD"}],"format":"cjs"},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytes":288,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytes":447,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"./shams"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytes":150,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytes":156,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"}],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytes":2043,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytes":126,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytes":99,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytes":132,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytes":280,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js","kind":"require-call","original":"./reflectApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytes":511,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytes":980,"imports":[{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytes":821,"imports":[{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"./Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"./Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js","kind":"require-call","original":"dunder-proto/get"}],"format":"cjs"},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"}],"format":"cjs"},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytes":14439,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js","kind":"require-call","original":"es-errors"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js","kind":"require-call","original":"es-errors/eval"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js","kind":"require-call","original":"es-errors/range"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js","kind":"require-call","original":"es-errors/ref"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js","kind":"require-call","original":"es-errors/uri"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js","kind":"require-call","original":"math-intrinsics/abs"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js","kind":"require-call","original":"math-intrinsics/floor"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js","kind":"require-call","original":"math-intrinsics/max"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js","kind":"require-call","original":"math-intrinsics/min"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js","kind":"require-call","original":"math-intrinsics/pow"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js","kind":"require-call","original":"math-intrinsics/round"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js","kind":"require-call","original":"math-intrinsics/sign"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js","kind":"require-call","original":"has-symbols"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"get-proto/Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"get-proto/Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"call-bind-apply-helpers/functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"call-bind-apply-helpers/functionCall"},{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js","kind":"require-call","original":"hasown"}],"format":"cjs"},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytes":2336,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytes":588,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"}],"format":"cjs"},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytes":1273,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js","kind":"require-call","original":"define-data-property"},{"path":"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js","kind":"require-call","original":"has-property-descriptors"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytes":264,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytes":643,"imports":[{"path":"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js","kind":"require-call","original":"set-function-length"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js","kind":"require-call","original":"call-bind-apply-helpers/applyBind"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytes":413,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"./"}],"format":"cjs"},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytes":976,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js","kind":"require-call","original":"call-bind/callBound"}],"format":"cjs"},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytes":964,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytes":3224,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytes":2374,"imports":[{"path":"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js","kind":"require-call","original":"is-callable"}],"format":"cjs"},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytes":264,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytes":475,"imports":[{"path":"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js","kind":"require-call","original":"possible-typed-array-names"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytes":687,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"}],"format":"cjs"},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytes":3647,"imports":[{"path":"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js","kind":"require-call","original":"for-each"},{"path":"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js","kind":"require-call","original":"available-typed-arrays"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js","kind":"require-call","original":"call-bound"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytes":180,"imports":[{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytes":8672,"imports":[{"path":"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js","kind":"require-call","original":"is-arguments"},{"path":"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js","kind":"require-call","original":"is-generator-function"},{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"},{"path":"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js","kind":"require-call","original":"is-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js":{"bytes":203,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytes":753,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytes":19697,"imports":[{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js","kind":"require-call","original":"./support/types"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js","kind":"require-call","original":"./support/isBuffer"},{"path":"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js","kind":"require-call","original":"inherits"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js":{"bytes":7309,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"require-call","original":"../assert"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"require-call","original":"../assert"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js":{"bytes":21906,"imports":[{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js","kind":"require-call","original":"../errors"}],"format":"cjs"},"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js":{"bytes":1164,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js":{"bytes":422,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js":{"bytes":3218,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js","kind":"require-call","original":"./isArguments"}],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js":{"bytes":823,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js","kind":"require-call","original":"./isArguments"},{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js":{"bytes":1268,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js","kind":"require-call","original":"object-keys"},{"path":"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js","kind":"require-call","original":"define-data-property"},{"path":"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js","kind":"require-call","original":"has-property-descriptors"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js":{"bytes":286,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js":{"bytes":181,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js":{"bytes":306,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js":{"bytes":390,"imports":[{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js","kind":"require-call","original":"./implementation"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js","kind":"require-call","original":"./shim"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js":{"bytes":156,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js":{"bytes":225,"imports":[{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js":{"bytes":387,"imports":[{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js","kind":"require-call","original":"./polyfill"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js":{"bytes":462,"imports":[{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js","kind":"require-call","original":"./implementation"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js","kind":"require-call","original":"./shim"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js":{"bytes":20712,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js","kind":"require-call","original":"object-is"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js","kind":"require-call","original":"is-nan"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js":{"bytes":19500,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js","kind":"require-call","original":"./internal/errors"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js","kind":"require-call","original":"./internal/assert/assertion_error"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js","kind":"require-call","original":"es6-object-assign"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js","kind":"require-call","original":"object-is"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js","kind":"require-call","original":"./internal/util/comparisons"}],"format":"cjs"},"src/assert.js":{"bytes":326,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"import-statement","original":"assert"}],"format":"esm"},"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytes":3932,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytes":2154,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytes":58353,"imports":[{"path":"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js","kind":"require-call","original":"base64-js"},{"path":"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js","kind":"require-call","original":"ieee754"}],"format":"cjs"},"src/buffer.js":{"bytes":68,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"}],"format":"esm"},"src/crypto.js":{"bytes":125,"imports":[],"format":"esm"},"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js":{"bytes":14890,"imports":[],"format":"cjs"},"src/events.js":{"bytes":133,"imports":[{"path":"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js","kind":"import-statement","original":"events"}],"format":"esm"},"src/fs.js":{"bytes":449,"imports":[],"format":"esm"},"src/fs/promises.js":{"bytes":1438,"imports":[],"format":"esm"},"src/process.js":{"bytes":3094,"imports":[],"format":"esm"},"src/globals.js":{"bytes":791,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"src/inject-globals.js":{"bytes":297,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytes":16166,"imports":[],"format":"cjs"},"src/path.js":{"bytes":243,"imports":[{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"},{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"}],"format":"esm"},"src/stream.js":{"bytes":138,"imports":[{"path":"readable-stream","kind":"import-statement","external":true}],"format":"esm"},"src/util.js":{"bytes":200,"imports":[{"path":"src/globals.js","kind":"import-statement","original":"./globals"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"}],"format":"esm"}},"outputs":{"dist/lib/browser/inject-globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":477},"dist/lib/browser/inject-globals.mjs":{"imports":[{"path":"dist/lib/browser/chunk-WA6DPORN.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-YERYCS33.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["Buffer","global","process"],"entryPoint":"src/inject-globals.js","inputs":{"src/inject-globals.js":{"bytesInOutput":75}},"bytes":403},"dist/lib/browser/path.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":25634},"dist/lib/browser/path.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["basename","default","dirname","extname","format","isAbsolute","join","normalize","parse","relative","resolve"],"entryPoint":"src/path.js","inputs":{"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytesInOutput":13382},"src/path.js":{"bytesInOutput":143}},"bytes":14593},"dist/lib/browser/stream.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":312},"dist/lib/browser/stream.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"},{"path":"readable-stream","kind":"import-statement","external":true}],"exports":["Duplex","PassThrough","Readable","Stream","Transform","Writable","pipeline"],"entryPoint":"src/stream.js","inputs":{"src/stream.js":{"bytesInOutput":104}},"bytes":284},"dist/lib/browser/util.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":411},"dist/lib/browser/util.mjs":{"imports":[{"path":"dist/lib/browser/chunk-N4SPVTGW.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-LJ5EWKWX.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-WA6DPORN.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-YERYCS33.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["callbackify","default","inspect","promisify"],"entryPoint":"src/util.js","inputs":{"src/util.js":{"bytesInOutput":133}},"bytes":659},"dist/lib/browser/_/config.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":539},"dist/lib/browser/_/config.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["GLOBALS","MODULES"],"entryPoint":"src/_/config.js","inputs":{"src/_/config.js":{"bytesInOutput":183}},"bytes":304},"dist/lib/browser/assert.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":131265},"dist/lib/browser/assert.mjs":{"imports":[{"path":"dist/lib/browser/chunk-N4SPVTGW.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["default"],"entryPoint":"src/assert.js","inputs":{"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js":{"bytesInOutput":7044},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js":{"bytesInOutput":19359},"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js":{"bytesInOutput":1286},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js":{"bytesInOutput":608},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js":{"bytesInOutput":4181},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js":{"bytesInOutput":1053},"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js":{"bytesInOutput":1612},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js":{"bytesInOutput":519},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js":{"bytesInOutput":344},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js":{"bytesInOutput":497},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js":{"bytesInOutput":539},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js":{"bytesInOutput":253},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js":{"bytesInOutput":399},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js":{"bytesInOutput":502},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js":{"bytesInOutput":532},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js":{"bytesInOutput":17984},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js":{"bytesInOutput":16837},"src/assert.js":{"bytesInOutput":94}},"bytes":75664},"dist/lib/browser/chunk-N4SPVTGW.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":125176},"dist/lib/browser/chunk-N4SPVTGW.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["require_call_bind","require_define_data_property","require_has_property_descriptors","require_util"],"inputs":{"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytesInOutput":1697},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytesInOutput":209},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytesInOutput":190},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytesInOutput":194},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytesInOutput":185},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytesInOutput":257},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytesInOutput":363},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytesInOutput":200},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytesInOutput":439},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytesInOutput":665},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytesInOutput":279},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytesInOutput":288},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytesInOutput":2255},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytesInOutput":289},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytesInOutput":246},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytesInOutput":249},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytesInOutput":281},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytesInOutput":432},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytesInOutput":598},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytesInOutput":1061},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytesInOutput":727},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytesInOutput":15079},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytesInOutput":2444},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytesInOutput":707},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytesInOutput":1723},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytesInOutput":423},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytesInOutput":842},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytesInOutput":612},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytesInOutput":1164},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytesInOutput":1263},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytesInOutput":3553},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytesInOutput":1930},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytesInOutput":503},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytesInOutput":608},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytesInOutput":785},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytesInOutput":3657},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytesInOutput":9169},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js":{"bytesInOutput":364},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytesInOutput":937},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytesInOutput":17677}},"bytes":82915},"dist/lib/browser/buffer.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":212},"dist/lib/browser/buffer.mjs":{"imports":[{"path":"dist/lib/browser/chunk-YERYCS33.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["Buffer"],"entryPoint":"src/buffer.js","inputs":{"src/buffer.js":{"bytesInOutput":50}},"bytes":291},"dist/lib/browser/crypto.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":308},"dist/lib/browser/crypto.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["randomBytes"],"entryPoint":"src/crypto.js","inputs":{"src/crypto.js":{"bytesInOutput":82}},"bytes":193},"dist/lib/browser/events.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":24175},"dist/lib/browser/events.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["EventEmitter","default"],"entryPoint":"src/events.js","inputs":{"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js":{"bytesInOutput":13175},"src/events.js":{"bytesInOutput":117}},"bytes":13618},"dist/lib/browser/fs.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":844},"dist/lib/browser/fs.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["appendFileSync","default","existsSync","mkdirSync","openSync","statSync"],"entryPoint":"src/fs.js","inputs":{"src/fs.js":{"bytesInOutput":367}},"bytes":549},"dist/lib/browser/fs/promises.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":2439},"dist/lib/browser/fs/promises.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["access","appendFile","chmod","chown","copyFile","cp","lchmod","lchown","link","lstat","lutimes","mkdir","mkdtemp","open","opendir","readFile","readdir","readlink","realpath","rename","rm","rmdir","stat","symlink","to","truncate","unlink","utimes","watch","writeFile"],"entryPoint":"src/fs/promises.js","inputs":{"src/fs/promises.js":{"bytesInOutput":1131}},"bytes":1533},"dist/lib/browser/globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/globals.mjs":{"imports":[{"path":"dist/lib/browser/chunk-LJ5EWKWX.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-WA6DPORN.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-YERYCS33.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":[],"entryPoint":"src/globals.js","inputs":{},"bytes":161},"dist/lib/browser/chunk-LJ5EWKWX.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":1288},"dist/lib/browser/chunk-LJ5EWKWX.mjs":{"imports":[{"path":"dist/lib/browser/chunk-WA6DPORN.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-YERYCS33.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":[],"inputs":{"src/globals.js":{"bytesInOutput":544}},"bytes":764},"dist/lib/browser/chunk-WA6DPORN.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5258},"dist/lib/browser/chunk-WA6DPORN.mjs":{"imports":[],"exports":["process"],"inputs":{"src/process.js":{"bytesInOutput":2367}},"bytes":2452},"dist/lib/browser/chunk-YERYCS33.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":111114},"dist/lib/browser/chunk-YERYCS33.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["require_buffer"],"inputs":{"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytesInOutput":3736},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytesInOutput":2514},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytesInOutput":56920}},"bytes":63838},"dist/lib/browser/chunk-3QS3WKRC.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/chunk-3QS3WKRC.mjs":{"imports":[],"exports":["__commonJS","__toESM"],"inputs":{},"bytes":1401}}}
+{"inputs":{"src/_/config.js":{"bytes":237,"imports":[],"format":"esm"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytes":1922,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytes":189,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"has-symbols/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytes":67,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytes":66,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytes":121,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytes":214,"imports":[{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js","kind":"require-call","original":"./isNaN"}],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js","kind":"require-call","original":"./gOPD"}],"format":"cjs"},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytes":288,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytes":447,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"./shams"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytes":150,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytes":156,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"}],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytes":2043,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytes":126,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytes":99,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytes":132,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytes":280,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js","kind":"require-call","original":"./reflectApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytes":511,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytes":980,"imports":[{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytes":821,"imports":[{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"./Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"./Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js","kind":"require-call","original":"dunder-proto/get"}],"format":"cjs"},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"}],"format":"cjs"},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytes":14439,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js","kind":"require-call","original":"es-errors"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js","kind":"require-call","original":"es-errors/eval"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js","kind":"require-call","original":"es-errors/range"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js","kind":"require-call","original":"es-errors/ref"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js","kind":"require-call","original":"es-errors/uri"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js","kind":"require-call","original":"math-intrinsics/abs"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js","kind":"require-call","original":"math-intrinsics/floor"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js","kind":"require-call","original":"math-intrinsics/max"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js","kind":"require-call","original":"math-intrinsics/min"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js","kind":"require-call","original":"math-intrinsics/pow"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js","kind":"require-call","original":"math-intrinsics/round"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js","kind":"require-call","original":"math-intrinsics/sign"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js","kind":"require-call","original":"has-symbols"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"get-proto/Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"get-proto/Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"call-bind-apply-helpers/functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"call-bind-apply-helpers/functionCall"},{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js","kind":"require-call","original":"hasown"}],"format":"cjs"},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytes":2336,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytes":588,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"}],"format":"cjs"},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytes":1273,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js","kind":"require-call","original":"define-data-property"},{"path":"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js","kind":"require-call","original":"has-property-descriptors"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytes":264,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytes":643,"imports":[{"path":"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js","kind":"require-call","original":"set-function-length"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js","kind":"require-call","original":"call-bind-apply-helpers/applyBind"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytes":413,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"./"}],"format":"cjs"},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytes":976,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js","kind":"require-call","original":"call-bind/callBound"}],"format":"cjs"},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytes":964,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytes":3224,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytes":2374,"imports":[{"path":"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js","kind":"require-call","original":"is-callable"}],"format":"cjs"},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytes":264,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytes":475,"imports":[{"path":"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js","kind":"require-call","original":"possible-typed-array-names"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytes":687,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"}],"format":"cjs"},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytes":3647,"imports":[{"path":"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js","kind":"require-call","original":"for-each"},{"path":"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js","kind":"require-call","original":"available-typed-arrays"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js","kind":"require-call","original":"call-bound"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytes":180,"imports":[{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytes":8672,"imports":[{"path":"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js","kind":"require-call","original":"is-arguments"},{"path":"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js","kind":"require-call","original":"is-generator-function"},{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"},{"path":"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js","kind":"require-call","original":"is-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js":{"bytes":203,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytes":753,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytes":19697,"imports":[{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js","kind":"require-call","original":"./support/types"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js","kind":"require-call","original":"./support/isBuffer"},{"path":"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js","kind":"require-call","original":"inherits"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js":{"bytes":7309,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"require-call","original":"../assert"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"require-call","original":"../assert"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js":{"bytes":21906,"imports":[{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js","kind":"require-call","original":"../errors"}],"format":"cjs"},"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js":{"bytes":1164,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js":{"bytes":422,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js":{"bytes":3218,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js","kind":"require-call","original":"./isArguments"}],"format":"cjs"},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js":{"bytes":823,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js","kind":"require-call","original":"./isArguments"},{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js":{"bytes":1268,"imports":[{"path":"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js","kind":"require-call","original":"object-keys"},{"path":"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js","kind":"require-call","original":"define-data-property"},{"path":"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js","kind":"require-call","original":"has-property-descriptors"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js":{"bytes":286,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js":{"bytes":181,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js":{"bytes":306,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"}],"format":"cjs"},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js":{"bytes":390,"imports":[{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js","kind":"require-call","original":"./implementation"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js","kind":"require-call","original":"./shim"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js":{"bytes":156,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js":{"bytes":225,"imports":[{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js":{"bytes":387,"imports":[{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js","kind":"require-call","original":"./polyfill"}],"format":"cjs"},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js":{"bytes":462,"imports":[{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js","kind":"require-call","original":"define-properties"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js","kind":"require-call","original":"./implementation"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js","kind":"require-call","original":"./polyfill"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js","kind":"require-call","original":"./shim"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js":{"bytes":20712,"imports":[{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js","kind":"require-call","original":"object-is"},{"path":"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js","kind":"require-call","original":"is-nan"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"}],"format":"cjs"},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js":{"bytes":19500,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js","kind":"require-call","original":"./internal/errors"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js","kind":"require-call","original":"./internal/assert/assertion_error"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"require-call","original":"util/"},{"path":"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js","kind":"require-call","original":"es6-object-assign"},{"path":"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js","kind":"require-call","original":"object-is"},{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js","kind":"require-call","original":"./internal/util/comparisons"}],"format":"cjs"},"src/assert.js":{"bytes":326,"imports":[{"path":"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js","kind":"import-statement","original":"assert"}],"format":"esm"},"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytes":3932,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytes":2154,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytes":58353,"imports":[{"path":"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js","kind":"require-call","original":"base64-js"},{"path":"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js","kind":"require-call","original":"ieee754"}],"format":"cjs"},"src/buffer.js":{"bytes":68,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"}],"format":"esm"},"src/crypto.js":{"bytes":125,"imports":[],"format":"esm"},"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js":{"bytes":14890,"imports":[],"format":"cjs"},"src/events.js":{"bytes":133,"imports":[{"path":"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js","kind":"import-statement","original":"events"}],"format":"esm"},"src/fs.js":{"bytes":449,"imports":[],"format":"esm"},"src/fs/promises.js":{"bytes":1438,"imports":[],"format":"esm"},"src/process.js":{"bytes":3094,"imports":[],"format":"esm"},"src/globals.js":{"bytes":791,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"src/inject-globals.js":{"bytes":297,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytes":16166,"imports":[],"format":"cjs"},"src/path.js":{"bytes":243,"imports":[{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"},{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"}],"format":"esm"},"src/stream.js":{"bytes":138,"imports":[{"path":"readable-stream","kind":"import-statement","external":true}],"format":"esm"},"src/util.js":{"bytes":257,"imports":[{"path":"src/globals.js","kind":"import-statement","original":"./globals"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"}],"format":"esm"}},"outputs":{"dist/lib/browser/inject-globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":477},"dist/lib/browser/inject-globals.mjs":{"imports":[{"path":"dist/lib/browser/chunk-QN6WLX5Z.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-DDIIPJLY.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["Buffer","global","process"],"entryPoint":"src/inject-globals.js","inputs":{"src/inject-globals.js":{"bytesInOutput":75}},"bytes":403},"dist/lib/browser/path.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":25634},"dist/lib/browser/path.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["basename","default","dirname","extname","format","isAbsolute","join","normalize","parse","relative","resolve"],"entryPoint":"src/path.js","inputs":{"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytesInOutput":13382},"src/path.js":{"bytesInOutput":143}},"bytes":14593},"dist/lib/browser/process.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/process.mjs":{"imports":[{"path":"dist/lib/browser/chunk-QN6WLX5Z.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["process"],"entryPoint":"src/process.js","inputs":{},"bytes":140},"dist/lib/browser/stream.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":312},"dist/lib/browser/stream.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"},{"path":"readable-stream","kind":"import-statement","external":true}],"exports":["Duplex","PassThrough","Readable","Stream","Transform","Writable","pipeline"],"entryPoint":"src/stream.js","inputs":{"src/stream.js":{"bytesInOutput":104}},"bytes":284},"dist/lib/browser/util.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":468},"dist/lib/browser/util.mjs":{"imports":[{"path":"dist/lib/browser/chunk-6QJFTFAJ.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-2OGZPQMO.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-QN6WLX5Z.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-DDIIPJLY.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["callbackify","debuglog","default","format","inspect","promisify","stripVTControlCharacters"],"entryPoint":"src/util.js","inputs":{"src/util.js":{"bytesInOutput":133}},"bytes":943},"dist/lib/browser/_/config.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":539},"dist/lib/browser/_/config.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["GLOBALS","MODULES"],"entryPoint":"src/_/config.js","inputs":{"src/_/config.js":{"bytesInOutput":183}},"bytes":304},"dist/lib/browser/assert.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":131265},"dist/lib/browser/assert.mjs":{"imports":[{"path":"dist/lib/browser/chunk-6QJFTFAJ.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["default"],"entryPoint":"src/assert.js","inputs":{"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js":{"bytesInOutput":7046},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js":{"bytesInOutput":19361},"../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js":{"bytesInOutput":1286},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js":{"bytesInOutput":608},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js":{"bytesInOutput":4183},"../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js":{"bytesInOutput":1055},"../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js":{"bytesInOutput":1612},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js":{"bytesInOutput":519},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js":{"bytesInOutput":344},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js":{"bytesInOutput":497},"../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js":{"bytesInOutput":539},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js":{"bytesInOutput":253},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js":{"bytesInOutput":399},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js":{"bytesInOutput":502},"../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js":{"bytesInOutput":532},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js":{"bytesInOutput":17984},"../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js":{"bytesInOutput":16837},"src/assert.js":{"bytesInOutput":94}},"bytes":75672},"dist/lib/browser/chunk-6QJFTFAJ.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":125176},"dist/lib/browser/chunk-6QJFTFAJ.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["require_call_bind","require_define_data_property","require_has_property_descriptors","require_util"],"inputs":{"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytesInOutput":1697},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytesInOutput":209},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytesInOutput":190},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytesInOutput":194},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytesInOutput":185},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytesInOutput":257},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytesInOutput":363},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytesInOutput":200},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytesInOutput":439},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytesInOutput":665},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytesInOutput":279},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytesInOutput":288},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytesInOutput":2255},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytesInOutput":289},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytesInOutput":246},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytesInOutput":249},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytesInOutput":281},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytesInOutput":432},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytesInOutput":598},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytesInOutput":1061},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytesInOutput":727},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytesInOutput":15081},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytesInOutput":2444},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytesInOutput":707},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytesInOutput":1723},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytesInOutput":423},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytesInOutput":842},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytesInOutput":612},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytesInOutput":1166},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytesInOutput":1263},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytesInOutput":3553},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytesInOutput":1930},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytesInOutput":503},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytesInOutput":608},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytesInOutput":785},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytesInOutput":3657},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytesInOutput":9169},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js":{"bytesInOutput":364},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytesInOutput":937},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytesInOutput":17677}},"bytes":82919},"dist/lib/browser/buffer.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":212},"dist/lib/browser/buffer.mjs":{"imports":[{"path":"dist/lib/browser/chunk-DDIIPJLY.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["Buffer"],"entryPoint":"src/buffer.js","inputs":{"src/buffer.js":{"bytesInOutput":50}},"bytes":291},"dist/lib/browser/crypto.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":308},"dist/lib/browser/crypto.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["randomBytes"],"entryPoint":"src/crypto.js","inputs":{"src/crypto.js":{"bytesInOutput":82}},"bytes":193},"dist/lib/browser/events.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":24175},"dist/lib/browser/events.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["EventEmitter","default"],"entryPoint":"src/events.js","inputs":{"../../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js":{"bytesInOutput":13175},"src/events.js":{"bytesInOutput":117}},"bytes":13618},"dist/lib/browser/fs.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":844},"dist/lib/browser/fs.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["appendFileSync","default","existsSync","mkdirSync","openSync","statSync"],"entryPoint":"src/fs.js","inputs":{"src/fs.js":{"bytesInOutput":367}},"bytes":549},"dist/lib/browser/fs/promises.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":2439},"dist/lib/browser/fs/promises.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["access","appendFile","chmod","chown","copyFile","cp","lchmod","lchown","link","lstat","lutimes","mkdir","mkdtemp","open","opendir","readFile","readdir","readlink","realpath","rename","rm","rmdir","stat","symlink","to","truncate","unlink","utimes","watch","writeFile"],"entryPoint":"src/fs/promises.js","inputs":{"src/fs/promises.js":{"bytesInOutput":1131}},"bytes":1533},"dist/lib/browser/globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/globals.mjs":{"imports":[{"path":"dist/lib/browser/chunk-2OGZPQMO.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-QN6WLX5Z.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-DDIIPJLY.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":[],"entryPoint":"src/globals.js","inputs":{},"bytes":161},"dist/lib/browser/chunk-2OGZPQMO.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":1288},"dist/lib/browser/chunk-2OGZPQMO.mjs":{"imports":[{"path":"dist/lib/browser/chunk-QN6WLX5Z.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-DDIIPJLY.mjs","kind":"import-statement"},{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":[],"inputs":{"src/globals.js":{"bytesInOutput":544}},"bytes":764},"dist/lib/browser/chunk-QN6WLX5Z.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5258},"dist/lib/browser/chunk-QN6WLX5Z.mjs":{"imports":[],"exports":["process"],"inputs":{"src/process.js":{"bytesInOutput":2367}},"bytes":2452},"dist/lib/browser/chunk-DDIIPJLY.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":111114},"dist/lib/browser/chunk-DDIIPJLY.mjs":{"imports":[{"path":"dist/lib/browser/chunk-3QS3WKRC.mjs","kind":"import-statement"}],"exports":["require_buffer"],"inputs":{"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytesInOutput":3736},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytesInOutput":2514},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytesInOutput":56922}},"bytes":63840},"dist/lib/browser/chunk-3QS3WKRC.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/chunk-3QS3WKRC.mjs":{"imports":[],"exports":["__commonJS","__toESM"],"inputs":{},"bytes":1401}}}

dist/lib/browser/util.mjs

 import {
   require_util
-} from "./chunk-N4SPVTGW.mjs";
-import "./chunk-LJ5EWKWX.mjs";
-import "./chunk-WA6DPORN.mjs";
-import "./chunk-YERYCS33.mjs";
+} from "./chunk-6QJFTFAJ.mjs";
+import "./chunk-2OGZPQMO.mjs";
+import "./chunk-QN6WLX5Z.mjs";
+import "./chunk-DDIIPJLY.mjs";
 import {
@@ -16,10 +16,16 @@ __toESM
 var export_callbackify = import_util2.callbackify;
+var export_debuglog = import_util2.debuglog;
+var export_format = import_util2.format;
 var export_inspect = import_util2.inspect;
 var export_promisify = import_util2.promisify;
+var export_stripVTControlCharacters = import_util2.stripVTControlCharacters;
 export {
   export_callbackify as callbackify,
+  export_debuglog as debuglog,
   util_default as default,
+  export_format as format,
   export_inspect as inspect,
-  export_promisify as promisify
+  export_promisify as promisify,
+  export_stripVTControlCharacters as stripVTControlCharacters
 };
 //# sourceMappingURL=util.mjs.map

dist/lib/browser/util.mjs.map

 {
   "version": 3,
   "sources": ["../../../src/util.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\n// NOTE: util depends on process global.\nimport './globals';\nimport util from 'util/';\n\nexport default util;\nexport { callbackify, inspect, promisify } from 'util/';\n"],
-  "mappings": ";;;;;;;;;;;AAMA,kBAAiB;AAGjB,IAAAA,eAAgD;AADhD,IAAO,eAAQ,YAAAC;",
+  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\n// NOTE: The `util` module depends on process global.\nimport './globals';\nimport util from 'util/';\n\nexport { callbackify, debuglog, format, inspect, promisify, stripVTControlCharacters } from 'util/';\nexport default util;\n"],
+  "mappings": ";;;;;;;;;;;AAMA,kBAAiB;AAEjB,IAAAA,eAA4F;AAC5F,IAAO,eAAQ,YAAAC;",
   "names": ["import_util", "util"]
 }

package.json

 {
   "name": "@dxos/node-std",
-  "version": "0.8.4-main.1f223c7",
+  "version": "0.8.4-main.21d9917",
   "description": "Simple wrapper for browser replacements of node stdlib modules within the DXOS codebase.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
@@ -13,16 +17,53 @@ "author": "DXOS.org",
     "./_/config": {
-      "import": "./dist/lib/browser/_/config.mjs",
-      "require": "./dist/lib/node-esm/_/config.mjs"
+      "browser": "./dist/lib/browser/_/config.mjs",
+      "node": "./dist/lib/browser/_/config.mjs"
     },
-    "./assert": "./dist/lib/browser/assert.mjs",
-    "./buffer": "./dist/lib/browser/buffer.mjs",
-    "./crypto": "./dist/lib/browser/crypto.mjs",
-    "./events": "./dist/lib/browser/events.mjs",
-    "./fs": "./dist/lib/browser/fs.mjs",
-    "./fs/promises": "./dist/lib/browser/fs/promises.mjs",
-    "./globals": "./dist/lib/browser/globals.mjs",
-    "./inject-globals": "./dist/lib/browser/inject-globals.mjs",
-    "./path": "./dist/lib/browser/path.mjs",
-    "./stream": "./dist/lib/browser/stream.mjs",
-    "./util": "./dist/lib/browser/util.mjs"
+    "./assert": {
+      "browser": "./dist/lib/browser/assert.mjs",
+      "node": "./src/node/assert.js"
+    },
+    "./buffer": {
+      "browser": "./dist/lib/browser/buffer.mjs",
+      "node": "./src/node/buffer.js"
+    },
+    "./crypto": {
+      "browser": "./dist/lib/browser/crypto.mjs",
+      "node": "./src/node/crypto.js"
+    },
+    "./events": {
+      "browser": "./dist/lib/browser/events.mjs",
+      "node": "./src/node/events.js"
+    },
+    "./fs": {
+      "browser": "./dist/lib/browser/fs.mjs",
+      "node": "./src/node/fs.js"
+    },
+    "./fs/promises": {
+      "browser": "./dist/lib/browser/fs/promises.mjs",
+      "node": "./src/node/fs/promises.js"
+    },
+    "./globals": {
+      "browser": "./dist/lib/browser/globals.mjs",
+      "node": "./src/node/globals.js"
+    },
+    "./inject-globals": {
+      "browser": "./dist/lib/browser/inject-globals.mjs",
+      "node": "./src/node/inject-globals.js"
+    },
+    "./path": {
+      "browser": "./dist/lib/browser/path.mjs",
+      "node": "./src/node/path.js"
+    },
+    "./process": {
+      "browser": "./dist/lib/browser/process.mjs",
+      "node": "./src/node/process.js"
+    },
+    "./stream": {
+      "browser": "./dist/lib/browser/stream.mjs",
+      "node": "./src/node/stream.js"
+    },
+    "./util": {
+      "browser": "./dist/lib/browser/util.mjs",
+      "node": "./src/node/util.js"
+    }
   },
@@ -38,2 +79,3 @@ "typesVersions": {
     "dist",
+    "src/node",
     "types"
@@ -40,0 +82,0 @@ ],

dist/lib/browser/chunk-LJ5EWKWX.mjs

-import {
-  process
-} from "./chunk-WA6DPORN.mjs";
-import {
-  require_buffer
-} from "./chunk-YERYCS33.mjs";
-import {
-  __toESM
-} from "./chunk-3QS3WKRC.mjs";
-
-// src/globals.js
-var import_buffer = __toESM(require_buffer(), 1);
-(() => {
-  if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, "global")) {
-    Object.defineProperty(globalThis, "global", {
-      value: globalThis,
-      configurable: true,
-      writable: false,
-      enumerable: true
-    });
-  }
-  if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
-    globalThis.Buffer = import_buffer.Buffer;
-  }
-  if (typeof globalThis !== "undefined" && !globalThis.process) {
-    globalThis.process = process;
-  }
-})();
-//# sourceMappingURL=chunk-LJ5EWKWX.mjs.map

dist/lib/browser/chunk-LJ5EWKWX.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/globals.js"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Buffer } from 'buffer/';\n\nimport { process } from './process';\n\n(() => {\n  // NOTE(Zan): When running in native context `globalThis.global` is an immutable property.\n  // - Socket already polyfills it.\n\n  // Check if `globalThis` is defined and if `global` can be assigned.\n  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, 'global')) {\n    Object.defineProperty(globalThis, 'global', {\n      value: globalThis,\n      configurable: true,\n      writable: false,\n      enumerable: true,\n    });\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.Buffer) {\n    globalThis.Buffer = Buffer;\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.process) {\n    globalThis.process = process;\n  }\n})();\n"],
-  "mappings": ";;;;;;;;;;;AAIA,oBAAuB;CAItB,MAAM;AAKL,MAAI,OAAO,eAAe,eAAe,CAAC,OAAO,yBAAyB,YAAY,QAAQ,GAAG;AAC/F,WAAO,eAAe,YAAY,UAAU;AAAA,MAC1C,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV,YAAY;AAAA,IACd,CAAC;AAAA,EACH;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,QAAQ;AAC3D,eAAW,SAAS;AAAA,EACtB;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,SAAS;AAC5D,eAAW,UAAU;AAAA,EACvB;AACF,GAAG;",
-  "names": []
-}

dist/lib/browser/chunk-WA6DPORN.mjs

-// src/process.js
-function nextTick(fun, ...args) {
-  if (args.length > 0) {
-    queueMicrotask(() => fun(...args));
-  } else {
-    queueMicrotask(fun);
-  }
-}
-var title = "browser";
-var platform = "browser";
-var browser = true;
-var env = {};
-var argv = [];
-var version = "";
-var versions = {};
-var release = {};
-var config = {};
-function noop() {
-}
-var on = noop;
-var addListener = noop;
-var once = noop;
-var off = noop;
-var removeListener = noop;
-var removeAllListeners = noop;
-var emit = noop;
-function binding(name) {
-  throw new Error("process.binding is not supported");
-}
-function cwd() {
-  return "/";
-}
-function chdir(dir) {
-  throw new Error("process.chdir is not supported");
-}
-function umask() {
-  return 0;
-}
-var performance = globalThis.performance || {};
-var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
-  return (/* @__PURE__ */ new Date()).getTime();
-};
-function hrtime(previousTimestamp) {
-  var clocktime = performanceNow.call(performance) * 1e-3;
-  var seconds = Math.floor(clocktime);
-  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
-  if (previousTimestamp) {
-    seconds = seconds - previousTimestamp[0];
-    nanoseconds = nanoseconds - previousTimestamp[1];
-    if (nanoseconds < 0) {
-      seconds--;
-      nanoseconds += 1e9;
-    }
-  }
-  return [seconds, nanoseconds];
-}
-hrtime.bigint = function() {
-  var clocktime = performanceNow.call(performance) * 1e-3;
-  var seconds = Math.floor(clocktime);
-  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
-  return BigInt(seconds * 1e9) + BigInt(nanoseconds);
-};
-var startTime = /* @__PURE__ */ new Date();
-function uptime() {
-  var currentTime = /* @__PURE__ */ new Date();
-  var dif = currentTime - startTime;
-  return dif / 1e3;
-}
-var process = {
-  nextTick,
-  title,
-  browser,
-  env,
-  argv,
-  version,
-  versions,
-  on,
-  addListener,
-  once,
-  off,
-  removeListener,
-  removeAllListeners,
-  emit,
-  binding,
-  cwd,
-  chdir,
-  umask,
-  hrtime,
-  platform,
-  release,
-  config,
-  uptime
-};
-var defines = {};
-Object.keys(defines).forEach((key) => {
-  const segs = key.split(".");
-  let target = process;
-  for (let i = 0; i < segs.length; i++) {
-    const seg = segs[i];
-    if (i === segs.length - 1) {
-      target[seg] = defines[key];
-    } else {
-      target = target[seg] || (target[seg] = {});
-    }
-  }
-});
-
-export {
-  process
-};
-//# sourceMappingURL=chunk-WA6DPORN.mjs.map

dist/lib/browser/chunk-WA6DPORN.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/process.js"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\n// !!! Duplicated in @dxos/esbuild-plugins\n// TODO(dmaretskyi): Unify.\n\n// shim for using process in browser\n// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\n/* eslint-disable */\n\nfunction nextTick(fun, ...args) {\n  if (args.length > 0) {\n    queueMicrotask(() => fun(...args));\n  } else {\n    queueMicrotask(fun);\n  }\n}\n\nconst title = 'browser';\nconst platform = 'browser';\nconst browser = true;\nconst env = {};\nconst argv = [];\nconst version = ''; // empty string to avoid regexp issues\nconst versions = {};\nconst release = {};\nconst config = {};\n\nfunction noop() {}\n\nconst on = noop;\nconst addListener = noop;\nconst once = noop;\nconst off = noop;\nconst removeListener = noop;\nconst removeAllListeners = noop;\nconst emit = noop;\n\nfunction binding(name) {\n  throw new Error('process.binding is not supported');\n}\n\nfunction cwd() {\n  return '/';\n}\n\nfunction chdir(dir) {\n  throw new Error('process.chdir is not supported');\n}\n\nfunction umask() {\n  return 0;\n}\n\n// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\nvar performance = globalThis.performance || {};\nvar performanceNow =\n  performance.now ||\n  performance.mozNow ||\n  performance.msNow ||\n  performance.oNow ||\n  performance.webkitNow ||\n  function () {\n    return new Date().getTime();\n  };\n\n// generate timestamp or delta\n// see http://nodejs.org/api/process.html#process_process_hrtime\nfunction hrtime(previousTimestamp) {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  if (previousTimestamp) {\n    seconds = seconds - previousTimestamp[0];\n    nanoseconds = nanoseconds - previousTimestamp[1];\n    if (nanoseconds < 0) {\n      seconds--;\n      nanoseconds += 1e9;\n    }\n  }\n  return [seconds, nanoseconds];\n}\n\nhrtime.bigint = function () {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  return BigInt(seconds * 1e9) + BigInt(nanoseconds);\n};\n\nvar startTime = new Date();\n\nfunction uptime() {\n  var currentTime = new Date();\n  var dif = currentTime - startTime;\n  return dif / 1000;\n}\n\nexport var process = {\n  nextTick: nextTick,\n  title: title,\n  browser: browser,\n  env: env,\n  argv: argv,\n  version: version,\n  versions: versions,\n  on: on,\n  addListener: addListener,\n  once: once,\n  off: off,\n  removeListener: removeListener,\n  removeAllListeners: removeAllListeners,\n  emit: emit,\n  binding: binding,\n  cwd: cwd,\n  chdir: chdir,\n  umask: umask,\n  hrtime: hrtime,\n  platform: platform,\n  release: release,\n  config: config,\n  uptime: uptime,\n};\n\n// replace process.env.VAR with define\n\nconst defines = {};\nObject.keys(defines).forEach((key) => {\n  const segs = key.split('.');\n  let target = process;\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i];\n    if (i === segs.length - 1) {\n      target[seg] = defines[key];\n    } else {\n      target = target[seg] || (target[seg] = {});\n    }\n  }\n});\n"],
-  "mappings": ";AAYA,SAAS,SAAS,QAAQ,MAAM;AAC9B,MAAI,KAAK,SAAS,GAAG;AACnB,mBAAe,MAAM,IAAI,GAAG,IAAI,CAAC;AAAA,EACnC,OAAO;AACL,mBAAe,GAAG;AAAA,EACpB;AACF;AAEA,IAAM,QAAQ;AACd,IAAM,WAAW;AACjB,IAAM,UAAU;AAChB,IAAM,MAAM,CAAC;AACb,IAAM,OAAO,CAAC;AACd,IAAM,UAAU;AAChB,IAAM,WAAW,CAAC;AAClB,IAAM,UAAU,CAAC;AACjB,IAAM,SAAS,CAAC;AAEhB,SAAS,OAAO;AAAC;AAEjB,IAAM,KAAK;AACX,IAAM,cAAc;AACpB,IAAM,OAAO;AACb,IAAM,MAAM;AACZ,IAAM,iBAAiB;AACvB,IAAM,qBAAqB;AAC3B,IAAM,OAAO;AAEb,SAAS,QAAQ,MAAM;AACrB,QAAM,IAAI,MAAM,kCAAkC;AACpD;AAEA,SAAS,MAAM;AACb,SAAO;AACT;AAEA,SAAS,MAAM,KAAK;AAClB,QAAM,IAAI,MAAM,gCAAgC;AAClD;AAEA,SAAS,QAAQ;AACf,SAAO;AACT;AAGA,IAAI,cAAc,WAAW,eAAe,CAAC;AAC7C,IAAI,iBACF,YAAY,OACZ,YAAY,UACZ,YAAY,SACZ,YAAY,QACZ,YAAY,aACZ,WAAY;AACV,UAAO,oBAAI,KAAK,GAAE,QAAQ;AAC5B;AAIF,SAAS,OAAO,mBAAmB;AACjC,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,MAAI,mBAAmB;AACrB,cAAU,UAAU,kBAAkB,CAAC;AACvC,kBAAc,cAAc,kBAAkB,CAAC;AAC/C,QAAI,cAAc,GAAG;AACnB;AACA,qBAAe;AAAA,IACjB;AAAA,EACF;AACA,SAAO,CAAC,SAAS,WAAW;AAC9B;AAEA,OAAO,SAAS,WAAY;AAC1B,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,SAAO,OAAO,UAAU,GAAG,IAAI,OAAO,WAAW;AACnD;AAEA,IAAI,YAAY,oBAAI,KAAK;AAEzB,SAAS,SAAS;AAChB,MAAI,cAAc,oBAAI,KAAK;AAC3B,MAAI,MAAM,cAAc;AACxB,SAAO,MAAM;AACf;AAEO,IAAI,UAAU;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIA,IAAM,UAAU,CAAC;AACjB,OAAO,KAAK,OAAO,EAAE,QAAQ,CAAC,QAAQ;AACpC,QAAM,OAAO,IAAI,MAAM,GAAG;AAC1B,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,MAAM,KAAK,SAAS,GAAG;AACzB,aAAO,GAAG,IAAI,QAAQ,GAAG;AAAA,IAC3B,OAAO;AACL,eAAS,OAAO,GAAG,MAAM,OAAO,GAAG,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACF,CAAC;",
-  "names": []
-}

dist/lib/browser/chunk-YERYCS33.mjs

-import {
-  __commonJS
-} from "./chunk-3QS3WKRC.mjs";
-
-// ../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
-var require_base64_js = __commonJS({
-  "../../../node_modules/.pnpm/base64-js@1.5.1/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/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
-var require_ieee754 = __commonJS({
-  "../../../node_modules/.pnpm/ieee754@1.2.1/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/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
-var require_buffer = __commonJS({
-  "../../../node_modules/.pnpm/buffer@6.0.3/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 = Buffer;
-    exports.SlowBuffer = SlowBuffer;
-    exports.INSPECT_MAX_BYTES = 50;
-    var K_MAX_LENGTH = 2147483647;
-    exports.kMaxLength = K_MAX_LENGTH;
-    Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
-    if (!Buffer.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(Buffer.prototype, "parent", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer.isBuffer(this)) return void 0;
-        return this.buffer;
-      }
-    });
-    Object.defineProperty(Buffer.prototype, "offset", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer.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, Buffer.prototype);
-      return buf;
-    }
-    function Buffer(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);
-    }
-    Buffer.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 Buffer.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 Buffer.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
-      );
-    }
-    Buffer.from = function(value, encodingOrOffset, length) {
-      return from(value, encodingOrOffset, length);
-    };
-    Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
-    Object.setPrototypeOf(Buffer, 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);
-    }
-    Buffer.alloc = function(size, fill, encoding) {
-      return alloc(size, fill, encoding);
-    };
-    function allocUnsafe(size) {
-      assertSize(size);
-      return createBuffer(size < 0 ? 0 : checked(size) | 0);
-    }
-    Buffer.allocUnsafe = function(size) {
-      return allocUnsafe(size);
-    };
-    Buffer.allocUnsafeSlow = function(size) {
-      return allocUnsafe(size);
-    };
-    function fromString(string, encoding) {
-      if (typeof encoding !== "string" || encoding === "") {
-        encoding = "utf8";
-      }
-      if (!Buffer.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, Buffer.prototype);
-      return buf;
-    }
-    function fromObject(obj) {
-      if (Buffer.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 Buffer.alloc(+length);
-    }
-    Buffer.isBuffer = function isBuffer(b) {
-      return b != null && b._isBuffer === true && b !== Buffer.prototype;
-    };
-    Buffer.compare = function compare(a, b) {
-      if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
-      if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
-      if (!Buffer.isBuffer(a) || !Buffer.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;
-    };
-    Buffer.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;
-      }
-    };
-    Buffer.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 Buffer.alloc(0);
-      }
-      let i;
-      if (length === void 0) {
-        length = 0;
-        for (i = 0; i < list.length; ++i) {
-          length += list[i].length;
-        }
-      }
-      const buffer = Buffer.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 (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
-            buf.copy(buffer, pos);
-          } else {
-            Uint8Array.prototype.set.call(
-              buffer,
-              buf,
-              pos
-            );
-          }
-        } else if (!Buffer.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 (Buffer.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;
-        }
-      }
-    }
-    Buffer.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;
-        }
-      }
-    }
-    Buffer.prototype._isBuffer = true;
-    function swap(b, n, m) {
-      const i = b[n];
-      b[n] = b[m];
-      b[m] = i;
-    }
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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);
-    };
-    Buffer.prototype.toLocaleString = Buffer.prototype.toString;
-    Buffer.prototype.equals = function equals(b) {
-      if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
-      if (this === b) return true;
-      return Buffer.compare(this, b) === 0;
-    };
-    Buffer.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) {
-      Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
-    }
-    Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
-      if (isInstance(target, Uint8Array)) {
-        target = Buffer.from(target, target.offset, target.byteLength);
-      }
-      if (!Buffer.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 = Buffer.from(val, encoding);
-      }
-      if (Buffer.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;
-    }
-    Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
-      return this.indexOf(val, byteOffset, encoding) !== -1;
-    };
-    Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
-      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
-    };
-    Buffer.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);
-    }
-    Buffer.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;
-        }
-      }
-    };
-    Buffer.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;
-    }
-    Buffer.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, Buffer.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");
-    }
-    Buffer.prototype.readUintLE = Buffer.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;
-    };
-    Buffer.prototype.readUintBE = Buffer.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;
-    };
-    Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 1, this.length);
-      return this[offset];
-    };
-    Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] | this[offset + 1] << 8;
-    };
-    Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] << 8 | this[offset + 1];
-    };
-    Buffer.prototype.readUint32LE = Buffer.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;
-    };
-    Buffer.prototype.readUint32BE = Buffer.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]);
-    };
-    Buffer.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));
-    });
-    Buffer.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);
-    });
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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];
-    };
-    Buffer.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);
-    });
-    Buffer.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);
-    });
-    Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee754.read(this, offset, true, 23, 4);
-    };
-    Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee754.read(this, offset, false, 23, 4);
-    };
-    Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 8, this.length);
-      return ieee754.read(this, offset, true, 52, 8);
-    };
-    Buffer.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 (!Buffer.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");
-    }
-    Buffer.prototype.writeUintLE = Buffer.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;
-    };
-    Buffer.prototype.writeUintBE = Buffer.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;
-    };
-    Buffer.prototype.writeUint8 = Buffer.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;
-    };
-    Buffer.prototype.writeUint16LE = Buffer.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;
-    };
-    Buffer.prototype.writeUint16BE = Buffer.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;
-    };
-    Buffer.prototype.writeUint32LE = Buffer.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;
-    };
-    Buffer.prototype.writeUint32BE = Buffer.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;
-    }
-    Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
-    Buffer.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;
-    }
-    Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
-      return writeFloat(this, value, offset, true, noAssert);
-    };
-    Buffer.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;
-    }
-    Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, true, noAssert);
-    };
-    Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, false, noAssert);
-    };
-    Buffer.prototype.copy = function copy(target, targetStart, start, end) {
-      if (!Buffer.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;
-    };
-    Buffer.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" && !Buffer.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 = Buffer.isBuffer(val) ? val : Buffer.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");
-    }
-  }
-});
-
-export {
-  require_buffer
-};
-/*! 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
-   *)
-*/
-//# sourceMappingURL=chunk-YERYCS33.mjs.map

dist/lib/node-esm/_/config.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "../chunk-RZY7P3LC.mjs";
-
-// src/_/config.js
-var GLOBALS = ["global", "Buffer", "process"];
-var MODULES = [
-  "fs/promises",
-  "assert",
-  "buffer",
-  "crypto",
-  "events",
-  "fs",
-  "path",
-  "process",
-  "stream",
-  "util"
-];
-export {
-  GLOBALS,
-  MODULES
-};
-//# sourceMappingURL=config.mjs.map

dist/lib/node-esm/_/config.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../../src/_/config.js"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nexport const GLOBALS = ['global', 'Buffer', 'process'];\n\nexport const MODULES = [\n  'fs/promises',\n  'assert',\n  'buffer',\n  'crypto',\n  'events',\n  'fs',\n  'path',\n  'process',\n  'stream',\n  'util',\n];\n"],
-  "mappings": ";;;;AAIO,IAAM,UAAU,CAAC,UAAU,UAAU,SAAS;AAE9C,IAAM,UAAU;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
-  "names": []
-}

dist/lib/node-esm/assert.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RZY7P3LC.mjs";
-
-// src/assert.js
-import assert from "assert";
-var assert_default = assert;
-export {
-  assert_default as default
-};
-//# sourceMappingURL=assert.mjs.map

dist/lib/node-esm/assert.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/assert.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\n// TODO(wittjosiah): Custom compilation script which only bundles the module being exported\n//  and replaces the internal usage of other stdlib modules with @dxos/node-std external refs.\n\n// TODO(burdon): import assert from 'node:assert'?\nimport assert from 'assert';\n\nexport default assert;\n"],
-  "mappings": ";;;;AAQA,OAAO,YAAY;AAEnB,IAAO,iBAAQ;",
-  "names": []
-}

dist/lib/node-esm/buffer.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  require_buffer
-} from "./chunk-F5GZS76O.mjs";
-import {
-  __toESM
-} from "./chunk-RZY7P3LC.mjs";
-
-// src/buffer.js
-var import_buffer = __toESM(require_buffer(), 1);
-var export_Buffer = import_buffer.Buffer;
-export {
-  export_Buffer as Buffer
-};
-//# sourceMappingURL=buffer.mjs.map

dist/lib/node-esm/buffer.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/buffer.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nexport { Buffer } from 'buffer/';\n"],
-  "mappings": ";;;;;;;;;AAIA,oBAAuB;",
-  "names": []
-}

dist/lib/node-esm/chunk-3EE3KRAW.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-
-// src/process.js
-function nextTick(fun, ...args) {
-  if (args.length > 0) {
-    queueMicrotask(() => fun(...args));
-  } else {
-    queueMicrotask(fun);
-  }
-}
-var title = "browser";
-var platform = "browser";
-var browser = true;
-var env = {};
-var argv = [];
-var version = "";
-var versions = {};
-var release = {};
-var config = {};
-function noop() {
-}
-var on = noop;
-var addListener = noop;
-var once = noop;
-var off = noop;
-var removeListener = noop;
-var removeAllListeners = noop;
-var emit = noop;
-function binding(name) {
-  throw new Error("process.binding is not supported");
-}
-function cwd() {
-  return "/";
-}
-function chdir(dir) {
-  throw new Error("process.chdir is not supported");
-}
-function umask() {
-  return 0;
-}
-var performance = globalThis.performance || {};
-var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
-  return (/* @__PURE__ */ new Date()).getTime();
-};
-function hrtime(previousTimestamp) {
-  var clocktime = performanceNow.call(performance) * 1e-3;
-  var seconds = Math.floor(clocktime);
-  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
-  if (previousTimestamp) {
-    seconds = seconds - previousTimestamp[0];
-    nanoseconds = nanoseconds - previousTimestamp[1];
-    if (nanoseconds < 0) {
-      seconds--;
-      nanoseconds += 1e9;
-    }
-  }
-  return [seconds, nanoseconds];
-}
-hrtime.bigint = function() {
-  var clocktime = performanceNow.call(performance) * 1e-3;
-  var seconds = Math.floor(clocktime);
-  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
-  return BigInt(seconds * 1e9) + BigInt(nanoseconds);
-};
-var startTime = /* @__PURE__ */ new Date();
-function uptime() {
-  var currentTime = /* @__PURE__ */ new Date();
-  var dif = currentTime - startTime;
-  return dif / 1e3;
-}
-var process = {
-  nextTick,
-  title,
-  browser,
-  env,
-  argv,
-  version,
-  versions,
-  on,
-  addListener,
-  once,
-  off,
-  removeListener,
-  removeAllListeners,
-  emit,
-  binding,
-  cwd,
-  chdir,
-  umask,
-  hrtime,
-  platform,
-  release,
-  config,
-  uptime
-};
-var defines = {};
-Object.keys(defines).forEach((key) => {
-  const segs = key.split(".");
-  let target = process;
-  for (let i = 0; i < segs.length; i++) {
-    const seg = segs[i];
-    if (i === segs.length - 1) {
-      target[seg] = defines[key];
-    } else {
-      target = target[seg] || (target[seg] = {});
-    }
-  }
-});
-
-export {
-  process
-};
-//# sourceMappingURL=chunk-3EE3KRAW.mjs.map

dist/lib/node-esm/chunk-3EE3KRAW.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/process.js"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\n// !!! Duplicated in @dxos/esbuild-plugins\n// TODO(dmaretskyi): Unify.\n\n// shim for using process in browser\n// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\n/* eslint-disable */\n\nfunction nextTick(fun, ...args) {\n  if (args.length > 0) {\n    queueMicrotask(() => fun(...args));\n  } else {\n    queueMicrotask(fun);\n  }\n}\n\nconst title = 'browser';\nconst platform = 'browser';\nconst browser = true;\nconst env = {};\nconst argv = [];\nconst version = ''; // empty string to avoid regexp issues\nconst versions = {};\nconst release = {};\nconst config = {};\n\nfunction noop() {}\n\nconst on = noop;\nconst addListener = noop;\nconst once = noop;\nconst off = noop;\nconst removeListener = noop;\nconst removeAllListeners = noop;\nconst emit = noop;\n\nfunction binding(name) {\n  throw new Error('process.binding is not supported');\n}\n\nfunction cwd() {\n  return '/';\n}\n\nfunction chdir(dir) {\n  throw new Error('process.chdir is not supported');\n}\n\nfunction umask() {\n  return 0;\n}\n\n// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\nvar performance = globalThis.performance || {};\nvar performanceNow =\n  performance.now ||\n  performance.mozNow ||\n  performance.msNow ||\n  performance.oNow ||\n  performance.webkitNow ||\n  function () {\n    return new Date().getTime();\n  };\n\n// generate timestamp or delta\n// see http://nodejs.org/api/process.html#process_process_hrtime\nfunction hrtime(previousTimestamp) {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  if (previousTimestamp) {\n    seconds = seconds - previousTimestamp[0];\n    nanoseconds = nanoseconds - previousTimestamp[1];\n    if (nanoseconds < 0) {\n      seconds--;\n      nanoseconds += 1e9;\n    }\n  }\n  return [seconds, nanoseconds];\n}\n\nhrtime.bigint = function () {\n  var clocktime = performanceNow.call(performance) * 1e-3;\n  var seconds = Math.floor(clocktime);\n  var nanoseconds = Math.floor((clocktime % 1) * 1e9);\n  return BigInt(seconds * 1e9) + BigInt(nanoseconds);\n};\n\nvar startTime = new Date();\n\nfunction uptime() {\n  var currentTime = new Date();\n  var dif = currentTime - startTime;\n  return dif / 1000;\n}\n\nexport var process = {\n  nextTick: nextTick,\n  title: title,\n  browser: browser,\n  env: env,\n  argv: argv,\n  version: version,\n  versions: versions,\n  on: on,\n  addListener: addListener,\n  once: once,\n  off: off,\n  removeListener: removeListener,\n  removeAllListeners: removeAllListeners,\n  emit: emit,\n  binding: binding,\n  cwd: cwd,\n  chdir: chdir,\n  umask: umask,\n  hrtime: hrtime,\n  platform: platform,\n  release: release,\n  config: config,\n  uptime: uptime,\n};\n\n// replace process.env.VAR with define\n\nconst defines = {};\nObject.keys(defines).forEach((key) => {\n  const segs = key.split('.');\n  let target = process;\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i];\n    if (i === segs.length - 1) {\n      target[seg] = defines[key];\n    } else {\n      target = target[seg] || (target[seg] = {});\n    }\n  }\n});\n"],
-  "mappings": ";;;AAYA,SAAS,SAAS,QAAQ,MAAM;AAC9B,MAAI,KAAK,SAAS,GAAG;AACnB,mBAAe,MAAM,IAAI,GAAG,IAAI,CAAC;AAAA,EACnC,OAAO;AACL,mBAAe,GAAG;AAAA,EACpB;AACF;AAEA,IAAM,QAAQ;AACd,IAAM,WAAW;AACjB,IAAM,UAAU;AAChB,IAAM,MAAM,CAAC;AACb,IAAM,OAAO,CAAC;AACd,IAAM,UAAU;AAChB,IAAM,WAAW,CAAC;AAClB,IAAM,UAAU,CAAC;AACjB,IAAM,SAAS,CAAC;AAEhB,SAAS,OAAO;AAAC;AAEjB,IAAM,KAAK;AACX,IAAM,cAAc;AACpB,IAAM,OAAO;AACb,IAAM,MAAM;AACZ,IAAM,iBAAiB;AACvB,IAAM,qBAAqB;AAC3B,IAAM,OAAO;AAEb,SAAS,QAAQ,MAAM;AACrB,QAAM,IAAI,MAAM,kCAAkC;AACpD;AAEA,SAAS,MAAM;AACb,SAAO;AACT;AAEA,SAAS,MAAM,KAAK;AAClB,QAAM,IAAI,MAAM,gCAAgC;AAClD;AAEA,SAAS,QAAQ;AACf,SAAO;AACT;AAGA,IAAI,cAAc,WAAW,eAAe,CAAC;AAC7C,IAAI,iBACF,YAAY,OACZ,YAAY,UACZ,YAAY,SACZ,YAAY,QACZ,YAAY,aACZ,WAAY;AACV,UAAO,oBAAI,KAAK,GAAE,QAAQ;AAC5B;AAIF,SAAS,OAAO,mBAAmB;AACjC,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,MAAI,mBAAmB;AACrB,cAAU,UAAU,kBAAkB,CAAC;AACvC,kBAAc,cAAc,kBAAkB,CAAC;AAC/C,QAAI,cAAc,GAAG;AACnB;AACA,qBAAe;AAAA,IACjB;AAAA,EACF;AACA,SAAO,CAAC,SAAS,WAAW;AAC9B;AAEA,OAAO,SAAS,WAAY;AAC1B,MAAI,YAAY,eAAe,KAAK,WAAW,IAAI;AACnD,MAAI,UAAU,KAAK,MAAM,SAAS;AAClC,MAAI,cAAc,KAAK,MAAO,YAAY,IAAK,GAAG;AAClD,SAAO,OAAO,UAAU,GAAG,IAAI,OAAO,WAAW;AACnD;AAEA,IAAI,YAAY,oBAAI,KAAK;AAEzB,SAAS,SAAS;AAChB,MAAI,cAAc,oBAAI,KAAK;AAC3B,MAAI,MAAM,cAAc;AACxB,SAAO,MAAM;AACf;AAEO,IAAI,UAAU;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIA,IAAM,UAAU,CAAC;AACjB,OAAO,KAAK,OAAO,EAAE,QAAQ,CAAC,QAAQ;AACpC,QAAM,OAAO,IAAI,MAAM,GAAG;AAC1B,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,MAAM,KAAK,SAAS,GAAG;AACzB,aAAO,GAAG,IAAI,QAAQ,GAAG;AAAA,IAC3B,OAAO;AACL,eAAS,OAAO,GAAG,MAAM,OAAO,GAAG,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACF,CAAC;",
-  "names": []
-}

dist/lib/node-esm/chunk-F5GZS76O.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  __commonJS
-} from "./chunk-RZY7P3LC.mjs";
-
-// ../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
-var require_base64_js = __commonJS({
-  "../../../node_modules/.pnpm/base64-js@1.5.1/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/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
-var require_ieee754 = __commonJS({
-  "../../../node_modules/.pnpm/ieee754@1.2.1/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/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
-var require_buffer = __commonJS({
-  "../../../node_modules/.pnpm/buffer@6.0.3/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 = Buffer;
-    exports.SlowBuffer = SlowBuffer;
-    exports.INSPECT_MAX_BYTES = 50;
-    var K_MAX_LENGTH = 2147483647;
-    exports.kMaxLength = K_MAX_LENGTH;
-    Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
-    if (!Buffer.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(Buffer.prototype, "parent", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer.isBuffer(this)) return void 0;
-        return this.buffer;
-      }
-    });
-    Object.defineProperty(Buffer.prototype, "offset", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer.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, Buffer.prototype);
-      return buf;
-    }
-    function Buffer(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);
-    }
-    Buffer.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 Buffer.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 Buffer.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
-      );
-    }
-    Buffer.from = function(value, encodingOrOffset, length) {
-      return from(value, encodingOrOffset, length);
-    };
-    Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
-    Object.setPrototypeOf(Buffer, 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);
-    }
-    Buffer.alloc = function(size, fill, encoding) {
-      return alloc(size, fill, encoding);
-    };
-    function allocUnsafe(size) {
-      assertSize(size);
-      return createBuffer(size < 0 ? 0 : checked(size) | 0);
-    }
-    Buffer.allocUnsafe = function(size) {
-      return allocUnsafe(size);
-    };
-    Buffer.allocUnsafeSlow = function(size) {
-      return allocUnsafe(size);
-    };
-    function fromString(string, encoding) {
-      if (typeof encoding !== "string" || encoding === "") {
-        encoding = "utf8";
-      }
-      if (!Buffer.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, Buffer.prototype);
-      return buf;
-    }
-    function fromObject(obj) {
-      if (Buffer.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 Buffer.alloc(+length);
-    }
-    Buffer.isBuffer = function isBuffer(b) {
-      return b != null && b._isBuffer === true && b !== Buffer.prototype;
-    };
-    Buffer.compare = function compare(a, b) {
-      if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
-      if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
-      if (!Buffer.isBuffer(a) || !Buffer.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;
-    };
-    Buffer.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;
-      }
-    };
-    Buffer.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 Buffer.alloc(0);
-      }
-      let i;
-      if (length === void 0) {
-        length = 0;
-        for (i = 0; i < list.length; ++i) {
-          length += list[i].length;
-        }
-      }
-      const buffer = Buffer.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 (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
-            buf.copy(buffer, pos);
-          } else {
-            Uint8Array.prototype.set.call(
-              buffer,
-              buf,
-              pos
-            );
-          }
-        } else if (!Buffer.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 (Buffer.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;
-        }
-      }
-    }
-    Buffer.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;
-        }
-      }
-    }
-    Buffer.prototype._isBuffer = true;
-    function swap(b, n, m) {
-      const i = b[n];
-      b[n] = b[m];
-      b[m] = i;
-    }
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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);
-    };
-    Buffer.prototype.toLocaleString = Buffer.prototype.toString;
-    Buffer.prototype.equals = function equals(b) {
-      if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
-      if (this === b) return true;
-      return Buffer.compare(this, b) === 0;
-    };
-    Buffer.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) {
-      Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
-    }
-    Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
-      if (isInstance(target, Uint8Array)) {
-        target = Buffer.from(target, target.offset, target.byteLength);
-      }
-      if (!Buffer.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 = Buffer.from(val, encoding);
-      }
-      if (Buffer.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;
-    }
-    Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
-      return this.indexOf(val, byteOffset, encoding) !== -1;
-    };
-    Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
-      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
-    };
-    Buffer.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);
-    }
-    Buffer.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;
-        }
-      }
-    };
-    Buffer.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;
-    }
-    Buffer.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, Buffer.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");
-    }
-    Buffer.prototype.readUintLE = Buffer.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;
-    };
-    Buffer.prototype.readUintBE = Buffer.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;
-    };
-    Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 1, this.length);
-      return this[offset];
-    };
-    Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] | this[offset + 1] << 8;
-    };
-    Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] << 8 | this[offset + 1];
-    };
-    Buffer.prototype.readUint32LE = Buffer.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;
-    };
-    Buffer.prototype.readUint32BE = Buffer.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]);
-    };
-    Buffer.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));
-    });
-    Buffer.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);
-    });
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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];
-    };
-    Buffer.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);
-    });
-    Buffer.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);
-    });
-    Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee754.read(this, offset, true, 23, 4);
-    };
-    Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee754.read(this, offset, false, 23, 4);
-    };
-    Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 8, this.length);
-      return ieee754.read(this, offset, true, 52, 8);
-    };
-    Buffer.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 (!Buffer.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");
-    }
-    Buffer.prototype.writeUintLE = Buffer.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;
-    };
-    Buffer.prototype.writeUintBE = Buffer.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;
-    };
-    Buffer.prototype.writeUint8 = Buffer.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;
-    };
-    Buffer.prototype.writeUint16LE = Buffer.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;
-    };
-    Buffer.prototype.writeUint16BE = Buffer.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;
-    };
-    Buffer.prototype.writeUint32LE = Buffer.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;
-    };
-    Buffer.prototype.writeUint32BE = Buffer.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;
-    }
-    Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.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;
-    };
-    Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
-    Buffer.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;
-    }
-    Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
-      return writeFloat(this, value, offset, true, noAssert);
-    };
-    Buffer.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;
-    }
-    Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, true, noAssert);
-    };
-    Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, false, noAssert);
-    };
-    Buffer.prototype.copy = function copy(target, targetStart, start, end) {
-      if (!Buffer.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;
-    };
-    Buffer.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" && !Buffer.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 = Buffer.isBuffer(val) ? val : Buffer.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");
-    }
-  }
-});
-
-export {
-  require_buffer
-};
-/*! 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
-   *)
-*/
-//# sourceMappingURL=chunk-F5GZS76O.mjs.map

dist/lib/node-esm/chunk-RJ7I7ZC3.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  process
-} from "./chunk-3EE3KRAW.mjs";
-import {
-  require_buffer
-} from "./chunk-F5GZS76O.mjs";
-import {
-  __toESM
-} from "./chunk-RZY7P3LC.mjs";
-
-// src/globals.js
-var import_buffer = __toESM(require_buffer(), 1);
-(() => {
-  if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, "global")) {
-    Object.defineProperty(globalThis, "global", {
-      value: globalThis,
-      configurable: true,
-      writable: false,
-      enumerable: true
-    });
-  }
-  if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
-    globalThis.Buffer = import_buffer.Buffer;
-  }
-  if (typeof globalThis !== "undefined" && !globalThis.process) {
-    globalThis.process = process;
-  }
-})();
-//# sourceMappingURL=chunk-RJ7I7ZC3.mjs.map

dist/lib/node-esm/chunk-RJ7I7ZC3.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/globals.js"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Buffer } from 'buffer/';\n\nimport { process } from './process';\n\n(() => {\n  // NOTE(Zan): When running in native context `globalThis.global` is an immutable property.\n  // - Socket already polyfills it.\n\n  // Check if `globalThis` is defined and if `global` can be assigned.\n  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, 'global')) {\n    Object.defineProperty(globalThis, 'global', {\n      value: globalThis,\n      configurable: true,\n      writable: false,\n      enumerable: true,\n    });\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.Buffer) {\n    globalThis.Buffer = Buffer;\n  }\n\n  if (typeof globalThis !== 'undefined' && !globalThis.process) {\n    globalThis.process = process;\n  }\n})();\n"],
-  "mappings": ";;;;;;;;;;;;AAIA,oBAAuB;CAItB,MAAM;AAKL,MAAI,OAAO,eAAe,eAAe,CAAC,OAAO,yBAAyB,YAAY,QAAQ,GAAG;AAC/F,WAAO,eAAe,YAAY,UAAU;AAAA,MAC1C,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV,YAAY;AAAA,IACd,CAAC;AAAA,EACH;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,QAAQ;AAC3D,eAAW,SAAS;AAAA,EACtB;AAEA,MAAI,OAAO,eAAe,eAAe,CAAC,WAAW,SAAS;AAC5D,eAAW,UAAU;AAAA,EACvB;AACF,GAAG;",
-  "names": []
-}

dist/lib/node-esm/chunk-RZY7P3LC.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  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
-));
-
-export {
-  __require,
-  __commonJS,
-  __toESM
-};
-//# sourceMappingURL=chunk-RZY7P3LC.mjs.map

dist/lib/node-esm/chunk-RZY7P3LC.mjs.map

-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}

dist/lib/node-esm/crypto.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RZY7P3LC.mjs";
-
-// src/crypto.js
-var randomBytes = () => {
-  throw new Error("Not available on this platform");
-};
-export {
-  randomBytes
-};
-//# sourceMappingURL=crypto.mjs.map

dist/lib/node-esm/crypto.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/crypto.js"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nexport const randomBytes = () => {\n  throw new Error('Not available on this platform');\n};\n"],
-  "mappings": ";;;;AAIO,IAAM,cAAc,MAAM;AAC/B,QAAM,IAAI,MAAM,gCAAgC;AAClD;",
-  "names": []
-}

dist/lib/node-esm/events.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RZY7P3LC.mjs";
-
-// src/events.js
-import { EventEmitter } from "events";
-var events_default = { EventEmitter };
-export {
-  EventEmitter,
-  events_default as default
-};
-//# sourceMappingURL=events.mjs.map

dist/lib/node-esm/events.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/events.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nimport { EventEmitter } from 'events';\n\nexport { EventEmitter };\n\nexport default { EventEmitter };\n"],
-  "mappings": ";;;;AAIA,SAAS,oBAAoB;AAI7B,IAAO,iBAAQ,EAAE,aAAa;",
-  "names": []
-}

dist/lib/node-esm/fs.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RZY7P3LC.mjs";
-
-// src/fs.js
-var notAvailable = () => {
-  throw new Error("Not available on this platform");
-};
-var appendFileSync = () => notAvailable();
-var mkdirSync = () => notAvailable();
-var openSync = () => notAvailable();
-var existsSync = () => notAvailable();
-var statSync = () => notAvailable();
-var fs_default = {
-  appendFileSync,
-  mkdirSync,
-  openSync,
-  existsSync,
-  statSync
-};
-export {
-  appendFileSync,
-  fs_default as default,
-  existsSync,
-  mkdirSync,
-  openSync,
-  statSync
-};
-//# sourceMappingURL=fs.mjs.map

dist/lib/node-esm/fs.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/fs.js"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nconst notAvailable = () => {\n  throw new Error('Not available on this platform');\n};\n\nexport const appendFileSync = () => notAvailable();\nexport const mkdirSync = () => notAvailable();\nexport const openSync = () => notAvailable();\nexport const existsSync = () => notAvailable();\nexport const statSync = () => notAvailable();\n\nexport default {\n  appendFileSync,\n  mkdirSync,\n  openSync,\n  existsSync,\n  statSync,\n};\n"],
-  "mappings": ";;;;AAIA,IAAM,eAAe,MAAM;AACzB,QAAM,IAAI,MAAM,gCAAgC;AAClD;AAEO,IAAM,iBAAiB,MAAM,aAAa;AAC1C,IAAM,YAAY,MAAM,aAAa;AACrC,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,aAAa,MAAM,aAAa;AACtC,IAAM,WAAW,MAAM,aAAa;AAE3C,IAAO,aAAQ;AAAA,EACb;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
-  "names": []
-}

dist/lib/node-esm/fs/promises.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "../chunk-RZY7P3LC.mjs";
-
-// src/fs/promises.js
-var notAvailable = () => {
-  throw new Error("Not available on this platform");
-};
-var access = () => notAvailable();
-var copyFile = () => notAvailable();
-var open = () => notAvailable();
-var rename = () => notAvailable();
-var truncate = () => notAvailable();
-var rmdir = () => notAvailable();
-var rm = () => notAvailable();
-var mkdir = () => notAvailable();
-var readdir = () => notAvailable();
-var readlink = () => notAvailable();
-var symlink = () => notAvailable();
-var lstat = () => notAvailable();
-var stat = () => notAvailable();
-var link = () => notAvailable();
-var unlink = () => notAvailable();
-var chmod = () => notAvailable();
-var lchmod = () => notAvailable();
-var lchown = () => notAvailable();
-var lutimes = () => notAvailable();
-var chown = () => notAvailable();
-var utimes = () => notAvailable();
-var to = () => notAvailable();
-var realpath = () => notAvailable();
-var mkdtemp = () => notAvailable();
-var writeFile = () => notAvailable();
-var appendFile = () => notAvailable();
-var readFile = () => notAvailable();
-var opendir = () => notAvailable();
-var watch = () => notAvailable();
-var cp = () => notAvailable();
-export {
-  access,
-  appendFile,
-  chmod,
-  chown,
-  copyFile,
-  cp,
-  lchmod,
-  lchown,
-  link,
-  lstat,
-  lutimes,
-  mkdir,
-  mkdtemp,
-  open,
-  opendir,
-  readFile,
-  readdir,
-  readlink,
-  realpath,
-  rename,
-  rm,
-  rmdir,
-  stat,
-  symlink,
-  to,
-  truncate,
-  unlink,
-  utimes,
-  watch,
-  writeFile
-};
-//# sourceMappingURL=promises.mjs.map

dist/lib/node-esm/fs/promises.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../../src/fs/promises.js"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nconst notAvailable = () => {\n  throw new Error('Not available on this platform');\n};\n\nexport const access = () => notAvailable();\nexport const copyFile = () => notAvailable();\nexport const open = () => notAvailable();\nexport const rename = () => notAvailable();\nexport const truncate = () => notAvailable();\nexport const rmdir = () => notAvailable();\nexport const rm = () => notAvailable();\nexport const mkdir = () => notAvailable();\nexport const readdir = () => notAvailable();\nexport const readlink = () => notAvailable();\nexport const symlink = () => notAvailable();\nexport const lstat = () => notAvailable();\nexport const stat = () => notAvailable();\nexport const link = () => notAvailable();\nexport const unlink = () => notAvailable();\nexport const chmod = () => notAvailable();\nexport const lchmod = () => notAvailable();\nexport const lchown = () => notAvailable();\nexport const lutimes = () => notAvailable();\nexport const chown = () => notAvailable();\nexport const utimes = () => notAvailable();\nexport const to = () => notAvailable();\nexport const realpath = () => notAvailable();\nexport const mkdtemp = () => notAvailable();\nexport const writeFile = () => notAvailable();\nexport const appendFile = () => notAvailable();\nexport const readFile = () => notAvailable();\nexport const opendir = () => notAvailable();\nexport const watch = () => notAvailable();\nexport const cp = () => notAvailable();\n"],
-  "mappings": ";;;;AAIA,IAAM,eAAe,MAAM;AACzB,QAAM,IAAI,MAAM,gCAAgC;AAClD;AAEO,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,OAAO,MAAM,aAAa;AAChC,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,KAAK,MAAM,aAAa;AAC9B,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,UAAU,MAAM,aAAa;AACnC,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,UAAU,MAAM,aAAa;AACnC,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,OAAO,MAAM,aAAa;AAChC,IAAM,OAAO,MAAM,aAAa;AAChC,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,UAAU,MAAM,aAAa;AACnC,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,SAAS,MAAM,aAAa;AAClC,IAAM,KAAK,MAAM,aAAa;AAC9B,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,UAAU,MAAM,aAAa;AACnC,IAAM,YAAY,MAAM,aAAa;AACrC,IAAM,aAAa,MAAM,aAAa;AACtC,IAAM,WAAW,MAAM,aAAa;AACpC,IAAM,UAAU,MAAM,aAAa;AACnC,IAAM,QAAQ,MAAM,aAAa;AACjC,IAAM,KAAK,MAAM,aAAa;",
-  "names": []
-}

dist/lib/node-esm/globals.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RJ7I7ZC3.mjs";
-import "./chunk-3EE3KRAW.mjs";
-import "./chunk-F5GZS76O.mjs";
-import "./chunk-RZY7P3LC.mjs";
-//# sourceMappingURL=globals.mjs.map

dist/lib/node-esm/globals.mjs.map

-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}

dist/lib/node-esm/inject-globals.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  process
-} from "./chunk-3EE3KRAW.mjs";
-import {
-  require_buffer
-} from "./chunk-F5GZS76O.mjs";
-import {
-  __toESM
-} from "./chunk-RZY7P3LC.mjs";
-
-// src/inject-globals.js
-var import_buffer = __toESM(require_buffer(), 1);
-var global = globalThis;
-var export_Buffer = import_buffer.Buffer;
-export {
-  export_Buffer as Buffer,
-  global,
-  process
-};
-//# sourceMappingURL=inject-globals.mjs.map

dist/lib/node-esm/inject-globals.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/inject-globals.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\n// To be used with esbuild's inject option.\n\nimport { Buffer } from 'buffer/';\n\nimport { process } from './process';\n\nconst global = globalThis;\n\n// Keep in sync with packages/common/esbuild-plugins/src/node-external-plugin.ts\nexport { global, Buffer, process };\n"],
-  "mappings": ";;;;;;;;;;;;AAMA,oBAAuB;AAIvB,IAAM,SAAS;",
-  "names": []
-}

dist/lib/node-esm/meta.json

-{"inputs":{"src/_/config.js":{"bytes":237,"imports":[],"format":"esm"},"src/assert.js":{"bytes":326,"imports":[{"path":"assert","kind":"import-statement","external":true}],"format":"esm"},"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytes":3932,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytes":2154,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytes":58353,"imports":[{"path":"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js","kind":"require-call","original":"base64-js"},{"path":"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js","kind":"require-call","original":"ieee754"}],"format":"cjs"},"src/buffer.js":{"bytes":68,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"}],"format":"esm"},"src/crypto.js":{"bytes":125,"imports":[],"format":"esm"},"src/events.js":{"bytes":133,"imports":[{"path":"events","kind":"import-statement","external":true}],"format":"esm"},"src/fs.js":{"bytes":449,"imports":[],"format":"esm"},"src/fs/promises.js":{"bytes":1438,"imports":[],"format":"esm"},"src/process.js":{"bytes":3094,"imports":[],"format":"esm"},"src/globals.js":{"bytes":791,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"src/inject-globals.js":{"bytes":297,"imports":[{"path":"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js","kind":"import-statement","original":"buffer/"},{"path":"src/process.js","kind":"import-statement","original":"./process"}],"format":"esm"},"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytes":16166,"imports":[],"format":"cjs"},"src/path.js":{"bytes":243,"imports":[{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"},{"path":"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","kind":"import-statement","original":"path-browserify"}],"format":"esm"},"src/stream.js":{"bytes":138,"imports":[{"path":"readable-stream","kind":"import-statement","external":true}],"format":"esm"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytes":1922,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytes":189,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"has-symbols/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytes":67,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytes":66,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytes":79,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytes":75,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytes":73,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytes":77,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytes":121,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytes":214,"imports":[{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js","kind":"require-call","original":"./isNaN"}],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js","kind":"require-call","original":"./gOPD"}],"format":"cjs"},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytes":288,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytes":447,"imports":[{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js","kind":"require-call","original":"./shams"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytes":150,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytes":156,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"}],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytes":2043,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytes":126,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js","kind":"require-call","original":"./implementation"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytes":97,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytes":99,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytes":132,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytes":280,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js","kind":"require-call","original":"./reflectApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytes":511,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"./functionCall"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytes":980,"imports":[{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytes":821,"imports":[{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"./Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"./Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js","kind":"require-call","original":"dunder-proto/get"}],"format":"cjs"},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytes":206,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"}],"format":"cjs"},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytes":14439,"imports":[{"path":"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js","kind":"require-call","original":"es-object-atoms"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js","kind":"require-call","original":"es-errors"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js","kind":"require-call","original":"es-errors/eval"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js","kind":"require-call","original":"es-errors/range"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js","kind":"require-call","original":"es-errors/ref"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js","kind":"require-call","original":"es-errors/uri"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js","kind":"require-call","original":"math-intrinsics/abs"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js","kind":"require-call","original":"math-intrinsics/floor"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js","kind":"require-call","original":"math-intrinsics/max"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js","kind":"require-call","original":"math-intrinsics/min"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js","kind":"require-call","original":"math-intrinsics/pow"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js","kind":"require-call","original":"math-intrinsics/round"},{"path":"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js","kind":"require-call","original":"math-intrinsics/sign"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js","kind":"require-call","original":"has-symbols"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js","kind":"require-call","original":"get-proto/Object.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js","kind":"require-call","original":"get-proto/Reflect.getPrototypeOf"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"call-bind-apply-helpers/functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js","kind":"require-call","original":"call-bind-apply-helpers/functionCall"},{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js","kind":"require-call","original":"hasown"}],"format":"cjs"},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytes":2336,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js","kind":"require-call","original":"es-errors/syntax"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"}],"format":"cjs"},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytes":588,"imports":[{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"}],"format":"cjs"},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytes":1273,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js","kind":"require-call","original":"define-data-property"},{"path":"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js","kind":"require-call","original":"has-property-descriptors"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js","kind":"require-call","original":"es-errors/type"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytes":264,"imports":[{"path":"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js","kind":"require-call","original":"function-bind"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js","kind":"require-call","original":"./functionApply"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js","kind":"require-call","original":"./actualApply"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytes":643,"imports":[{"path":"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js","kind":"require-call","original":"set-function-length"},{"path":"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js","kind":"require-call","original":"es-define-property"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js","kind":"require-call","original":"call-bind-apply-helpers/applyBind"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytes":413,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"./"}],"format":"cjs"},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytes":976,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js","kind":"require-call","original":"call-bind/callBound"}],"format":"cjs"},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytes":964,"imports":[{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytes":3224,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytes":2374,"imports":[{"path":"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js","kind":"require-call","original":"is-callable"}],"format":"cjs"},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytes":264,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytes":475,"imports":[{"path":"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js","kind":"require-call","original":"possible-typed-array-names"}],"format":"cjs"},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytes":687,"imports":[{"path":"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js","kind":"require-call","original":"get-intrinsic"},{"path":"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js","kind":"require-call","original":"call-bind-apply-helpers"}],"format":"cjs"},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytes":3647,"imports":[{"path":"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js","kind":"require-call","original":"for-each"},{"path":"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js","kind":"require-call","original":"available-typed-arrays"},{"path":"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js","kind":"require-call","original":"call-bind"},{"path":"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js","kind":"require-call","original":"call-bound"},{"path":"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js","kind":"require-call","original":"gopd"},{"path":"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js","kind":"require-call","original":"get-proto"},{"path":"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js","kind":"require-call","original":"has-tostringtag/shams"}],"format":"cjs"},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytes":180,"imports":[{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytes":8672,"imports":[{"path":"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js","kind":"require-call","original":"is-arguments"},{"path":"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js","kind":"require-call","original":"is-generator-function"},{"path":"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js","kind":"require-call","original":"which-typed-array"},{"path":"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js","kind":"require-call","original":"is-typed-array"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBuffer.js":{"bytes":76,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytes":753,"imports":[],"format":"cjs"},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js":{"bytes":250,"imports":[{"path":"util","kind":"require-call","external":true},{"path":"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js","kind":"require-call","original":"./inherits_browser.js"}],"format":"cjs"},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytes":19697,"imports":[{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js","kind":"require-call","original":"./support/types"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBuffer.js","kind":"require-call","original":"./support/isBuffer"},{"path":"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js","kind":"require-call","original":"inherits"}],"format":"cjs"},"src/util.js":{"bytes":200,"imports":[{"path":"src/globals.js","kind":"import-statement","original":"./globals"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"},{"path":"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js","kind":"import-statement","original":"util/"}],"format":"esm"}},"outputs":{"dist/lib/node-esm/inject-globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":478},"dist/lib/node-esm/inject-globals.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-3EE3KRAW.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-F5GZS76O.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["Buffer","global","process"],"entryPoint":"src/inject-globals.js","inputs":{"src/inject-globals.js":{"bytesInOutput":75}},"bytes":495},"dist/lib/node-esm/path.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":25635},"dist/lib/node-esm/path.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["basename","default","dirname","extname","format","isAbsolute","join","normalize","parse","relative","resolve"],"entryPoint":"src/path.js","inputs":{"../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js":{"bytesInOutput":13382},"src/path.js":{"bytesInOutput":143}},"bytes":14685},"dist/lib/node-esm/stream.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":313},"dist/lib/node-esm/stream.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"},{"path":"readable-stream","kind":"import-statement","external":true}],"exports":["Duplex","PassThrough","Readable","Stream","Transform","Writable","pipeline"],"entryPoint":"src/stream.js","inputs":{"src/stream.js":{"bytesInOutput":104}},"bytes":376},"dist/lib/node-esm/util.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":125887},"dist/lib/node-esm/util.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RJ7I7ZC3.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-3EE3KRAW.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-F5GZS76O.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"},{"path":"util","kind":"require-call","external":true}],"exports":["callbackify","default","inspect","promisify"],"entryPoint":"src/util.js","inputs":{"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js":{"bytesInOutput":1697},"../../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js":{"bytesInOutput":209},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js":{"bytesInOutput":190},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js":{"bytesInOutput":191},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js":{"bytesInOutput":194},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js":{"bytesInOutput":188},"../../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js":{"bytesInOutput":185},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js":{"bytesInOutput":197},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js":{"bytesInOutput":203},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js":{"bytesInOutput":257},"../../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js":{"bytesInOutput":363},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js":{"bytesInOutput":200},"../../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js":{"bytesInOutput":321},"../../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js":{"bytesInOutput":439},"../../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js":{"bytesInOutput":665},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js":{"bytesInOutput":279},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js":{"bytesInOutput":288},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js":{"bytesInOutput":2255},"../../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js":{"bytesInOutput":289},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js":{"bytesInOutput":246},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js":{"bytesInOutput":249},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js":{"bytesInOutput":281},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js":{"bytesInOutput":432},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js":{"bytesInOutput":598},"../../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js":{"bytesInOutput":1061},"../../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js":{"bytesInOutput":727},"../../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js":{"bytesInOutput":15079},"../../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js":{"bytesInOutput":2444},"../../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js":{"bytesInOutput":707},"../../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js":{"bytesInOutput":1723},"../../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js":{"bytesInOutput":423},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js":{"bytesInOutput":842},"../../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js":{"bytesInOutput":612},"../../../node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js":{"bytesInOutput":1164},"../../../node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js":{"bytesInOutput":1263},"../../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js":{"bytesInOutput":3553},"../../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js":{"bytesInOutput":1930},"../../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js":{"bytesInOutput":503},"../../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js":{"bytesInOutput":608},"../../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js":{"bytesInOutput":785},"../../../node_modules/.pnpm/which-typed-array@1.1.19/node_modules/which-typed-array/index.js":{"bytesInOutput":3657},"../../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js":{"bytesInOutput":331},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js":{"bytesInOutput":9169},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBuffer.js":{"bytesInOutput":234},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js":{"bytesInOutput":937},"../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js":{"bytesInOutput":374},"../../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js":{"bytesInOutput":17674},"src/util.js":{"bytesInOutput":133}},"bytes":83739},"dist/lib/node-esm/_/config.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":540},"dist/lib/node-esm/_/config.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["GLOBALS","MODULES"],"entryPoint":"src/_/config.js","inputs":{"src/_/config.js":{"bytesInOutput":183}},"bytes":396},"dist/lib/node-esm/assert.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":492},"dist/lib/node-esm/assert.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"},{"path":"assert","kind":"import-statement","external":true}],"exports":["default"],"entryPoint":"src/assert.js","inputs":{"src/assert.js":{"bytesInOutput":58}},"bytes":275},"dist/lib/node-esm/buffer.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":213},"dist/lib/node-esm/buffer.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-F5GZS76O.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["Buffer"],"entryPoint":"src/buffer.js","inputs":{"src/buffer.js":{"bytesInOutput":50}},"bytes":383},"dist/lib/node-esm/crypto.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":309},"dist/lib/node-esm/crypto.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["randomBytes"],"entryPoint":"src/crypto.js","inputs":{"src/crypto.js":{"bytesInOutput":82}},"bytes":285},"dist/lib/node-esm/events.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":309},"dist/lib/node-esm/events.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"},{"path":"events","kind":"import-statement","external":true}],"exports":["EventEmitter","default"],"entryPoint":"src/events.js","inputs":{"src/events.js":{"bytesInOutput":78}},"bytes":311},"dist/lib/node-esm/fs.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":845},"dist/lib/node-esm/fs.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["appendFileSync","default","existsSync","mkdirSync","openSync","statSync"],"entryPoint":"src/fs.js","inputs":{"src/fs.js":{"bytesInOutput":367}},"bytes":641},"dist/lib/node-esm/fs/promises.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":2440},"dist/lib/node-esm/fs/promises.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["access","appendFile","chmod","chown","copyFile","cp","lchmod","lchown","link","lstat","lutimes","mkdir","mkdtemp","open","opendir","readFile","readdir","readlink","realpath","rename","rm","rmdir","stat","symlink","to","truncate","unlink","utimes","watch","writeFile"],"entryPoint":"src/fs/promises.js","inputs":{"src/fs/promises.js":{"bytesInOutput":1131}},"bytes":1625},"dist/lib/node-esm/globals.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/node-esm/globals.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RJ7I7ZC3.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-3EE3KRAW.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-F5GZS76O.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":[],"entryPoint":"src/globals.js","inputs":{},"bytes":253},"dist/lib/node-esm/chunk-RJ7I7ZC3.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":1289},"dist/lib/node-esm/chunk-RJ7I7ZC3.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-3EE3KRAW.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-F5GZS76O.mjs","kind":"import-statement"},{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":[],"inputs":{"src/globals.js":{"bytesInOutput":544}},"bytes":856},"dist/lib/node-esm/chunk-3EE3KRAW.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5260},"dist/lib/node-esm/chunk-3EE3KRAW.mjs":{"imports":[],"exports":["process"],"inputs":{"src/process.js":{"bytesInOutput":2367}},"bytes":2545},"dist/lib/node-esm/chunk-F5GZS76O.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":111115},"dist/lib/node-esm/chunk-F5GZS76O.mjs":{"imports":[{"path":"dist/lib/node-esm/chunk-RZY7P3LC.mjs","kind":"import-statement"}],"exports":["require_buffer"],"inputs":{"../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js":{"bytesInOutput":3736},"../../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js":{"bytesInOutput":2514},"../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js":{"bytesInOutput":56920}},"bytes":63930},"dist/lib/node-esm/chunk-RZY7P3LC.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/node-esm/chunk-RZY7P3LC.mjs":{"imports":[],"exports":["__commonJS","__require","__toESM"],"inputs":{},"bytes":1872}}}

dist/lib/node-esm/path.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-RZY7P3LC.mjs";
-
-// ../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js
-var require_path_browserify = __commonJS({
-  "../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js"(exports, module) {
-    "use strict";
-    function assertPath(path2) {
-      if (typeof path2 !== "string") {
-        throw new TypeError("Path must be a string. Received " + JSON.stringify(path2));
-      }
-    }
-    function normalizeStringPosix(path2, allowAboveRoot) {
-      var res = "";
-      var lastSegmentLength = 0;
-      var lastSlash = -1;
-      var dots = 0;
-      var code;
-      for (var i = 0; i <= path2.length; ++i) {
-        if (i < path2.length)
-          code = path2.charCodeAt(i);
-        else if (code === 47)
-          break;
-        else
-          code = 47;
-        if (code === 47) {
-          if (lastSlash === i - 1 || dots === 1) {
-          } else if (lastSlash !== i - 1 && dots === 2) {
-            if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
-              if (res.length > 2) {
-                var lastSlashIndex = res.lastIndexOf("/");
-                if (lastSlashIndex !== res.length - 1) {
-                  if (lastSlashIndex === -1) {
-                    res = "";
-                    lastSegmentLength = 0;
-                  } else {
-                    res = res.slice(0, lastSlashIndex);
-                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-                  }
-                  lastSlash = i;
-                  dots = 0;
-                  continue;
-                }
-              } else if (res.length === 2 || res.length === 1) {
-                res = "";
-                lastSegmentLength = 0;
-                lastSlash = i;
-                dots = 0;
-                continue;
-              }
-            }
-            if (allowAboveRoot) {
-              if (res.length > 0)
-                res += "/..";
-              else
-                res = "..";
-              lastSegmentLength = 2;
-            }
-          } else {
-            if (res.length > 0)
-              res += "/" + path2.slice(lastSlash + 1, i);
-            else
-              res = path2.slice(lastSlash + 1, i);
-            lastSegmentLength = i - lastSlash - 1;
-          }
-          lastSlash = i;
-          dots = 0;
-        } else if (code === 46 && dots !== -1) {
-          ++dots;
-        } else {
-          dots = -1;
-        }
-      }
-      return res;
-    }
-    function _format(sep, pathObject) {
-      var dir = pathObject.dir || pathObject.root;
-      var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-      if (!dir) {
-        return base;
-      }
-      if (dir === pathObject.root) {
-        return dir + base;
-      }
-      return dir + sep + base;
-    }
-    var posix = {
-      // path.resolve([from ...], to)
-      resolve: function resolve2() {
-        var resolvedPath = "";
-        var resolvedAbsolute = false;
-        var cwd;
-        for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-          var path2;
-          if (i >= 0)
-            path2 = arguments[i];
-          else {
-            if (cwd === void 0)
-              cwd = process.cwd();
-            path2 = cwd;
-          }
-          assertPath(path2);
-          if (path2.length === 0) {
-            continue;
-          }
-          resolvedPath = path2 + "/" + resolvedPath;
-          resolvedAbsolute = path2.charCodeAt(0) === 47;
-        }
-        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-        if (resolvedAbsolute) {
-          if (resolvedPath.length > 0)
-            return "/" + resolvedPath;
-          else
-            return "/";
-        } else if (resolvedPath.length > 0) {
-          return resolvedPath;
-        } else {
-          return ".";
-        }
-      },
-      normalize: function normalize2(path2) {
-        assertPath(path2);
-        if (path2.length === 0) return ".";
-        var isAbsolute2 = path2.charCodeAt(0) === 47;
-        var trailingSeparator = path2.charCodeAt(path2.length - 1) === 47;
-        path2 = normalizeStringPosix(path2, !isAbsolute2);
-        if (path2.length === 0 && !isAbsolute2) path2 = ".";
-        if (path2.length > 0 && trailingSeparator) path2 += "/";
-        if (isAbsolute2) return "/" + path2;
-        return path2;
-      },
-      isAbsolute: function isAbsolute2(path2) {
-        assertPath(path2);
-        return path2.length > 0 && path2.charCodeAt(0) === 47;
-      },
-      join: function join2() {
-        if (arguments.length === 0)
-          return ".";
-        var joined;
-        for (var i = 0; i < arguments.length; ++i) {
-          var arg = arguments[i];
-          assertPath(arg);
-          if (arg.length > 0) {
-            if (joined === void 0)
-              joined = arg;
-            else
-              joined += "/" + arg;
-          }
-        }
-        if (joined === void 0)
-          return ".";
-        return posix.normalize(joined);
-      },
-      relative: function relative2(from, to) {
-        assertPath(from);
-        assertPath(to);
-        if (from === to) return "";
-        from = posix.resolve(from);
-        to = posix.resolve(to);
-        if (from === to) return "";
-        var fromStart = 1;
-        for (; fromStart < from.length; ++fromStart) {
-          if (from.charCodeAt(fromStart) !== 47)
-            break;
-        }
-        var fromEnd = from.length;
-        var fromLen = fromEnd - fromStart;
-        var toStart = 1;
-        for (; toStart < to.length; ++toStart) {
-          if (to.charCodeAt(toStart) !== 47)
-            break;
-        }
-        var toEnd = to.length;
-        var toLen = toEnd - toStart;
-        var length = fromLen < toLen ? fromLen : toLen;
-        var lastCommonSep = -1;
-        var i = 0;
-        for (; i <= length; ++i) {
-          if (i === length) {
-            if (toLen > length) {
-              if (to.charCodeAt(toStart + i) === 47) {
-                return to.slice(toStart + i + 1);
-              } else if (i === 0) {
-                return to.slice(toStart + i);
-              }
-            } else if (fromLen > length) {
-              if (from.charCodeAt(fromStart + i) === 47) {
-                lastCommonSep = i;
-              } else if (i === 0) {
-                lastCommonSep = 0;
-              }
-            }
-            break;
-          }
-          var fromCode = from.charCodeAt(fromStart + i);
-          var toCode = to.charCodeAt(toStart + i);
-          if (fromCode !== toCode)
-            break;
-          else if (fromCode === 47)
-            lastCommonSep = i;
-        }
-        var out = "";
-        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-          if (i === fromEnd || from.charCodeAt(i) === 47) {
-            if (out.length === 0)
-              out += "..";
-            else
-              out += "/..";
-          }
-        }
-        if (out.length > 0)
-          return out + to.slice(toStart + lastCommonSep);
-        else {
-          toStart += lastCommonSep;
-          if (to.charCodeAt(toStart) === 47)
-            ++toStart;
-          return to.slice(toStart);
-        }
-      },
-      _makeLong: function _makeLong(path2) {
-        return path2;
-      },
-      dirname: function dirname2(path2) {
-        assertPath(path2);
-        if (path2.length === 0) return ".";
-        var code = path2.charCodeAt(0);
-        var hasRoot = code === 47;
-        var end = -1;
-        var matchedSlash = true;
-        for (var i = path2.length - 1; i >= 1; --i) {
-          code = path2.charCodeAt(i);
-          if (code === 47) {
-            if (!matchedSlash) {
-              end = i;
-              break;
-            }
-          } else {
-            matchedSlash = false;
-          }
-        }
-        if (end === -1) return hasRoot ? "/" : ".";
-        if (hasRoot && end === 1) return "//";
-        return path2.slice(0, end);
-      },
-      basename: function basename2(path2, ext) {
-        if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
-        assertPath(path2);
-        var start = 0;
-        var end = -1;
-        var matchedSlash = true;
-        var i;
-        if (ext !== void 0 && ext.length > 0 && ext.length <= path2.length) {
-          if (ext.length === path2.length && ext === path2) return "";
-          var extIdx = ext.length - 1;
-          var firstNonSlashEnd = -1;
-          for (i = path2.length - 1; i >= 0; --i) {
-            var code = path2.charCodeAt(i);
-            if (code === 47) {
-              if (!matchedSlash) {
-                start = i + 1;
-                break;
-              }
-            } else {
-              if (firstNonSlashEnd === -1) {
-                matchedSlash = false;
-                firstNonSlashEnd = i + 1;
-              }
-              if (extIdx >= 0) {
-                if (code === ext.charCodeAt(extIdx)) {
-                  if (--extIdx === -1) {
-                    end = i;
-                  }
-                } else {
-                  extIdx = -1;
-                  end = firstNonSlashEnd;
-                }
-              }
-            }
-          }
-          if (start === end) end = firstNonSlashEnd;
-          else if (end === -1) end = path2.length;
-          return path2.slice(start, end);
-        } else {
-          for (i = path2.length - 1; i >= 0; --i) {
-            if (path2.charCodeAt(i) === 47) {
-              if (!matchedSlash) {
-                start = i + 1;
-                break;
-              }
-            } else if (end === -1) {
-              matchedSlash = false;
-              end = i + 1;
-            }
-          }
-          if (end === -1) return "";
-          return path2.slice(start, end);
-        }
-      },
-      extname: function extname2(path2) {
-        assertPath(path2);
-        var startDot = -1;
-        var startPart = 0;
-        var end = -1;
-        var matchedSlash = true;
-        var preDotState = 0;
-        for (var i = path2.length - 1; i >= 0; --i) {
-          var code = path2.charCodeAt(i);
-          if (code === 47) {
-            if (!matchedSlash) {
-              startPart = i + 1;
-              break;
-            }
-            continue;
-          }
-          if (end === -1) {
-            matchedSlash = false;
-            end = i + 1;
-          }
-          if (code === 46) {
-            if (startDot === -1)
-              startDot = i;
-            else if (preDotState !== 1)
-              preDotState = 1;
-          } else if (startDot !== -1) {
-            preDotState = -1;
-          }
-        }
-        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
-        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
-        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-          return "";
-        }
-        return path2.slice(startDot, end);
-      },
-      format: function format2(pathObject) {
-        if (pathObject === null || typeof pathObject !== "object") {
-          throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
-        }
-        return _format("/", pathObject);
-      },
-      parse: function parse2(path2) {
-        assertPath(path2);
-        var ret = { root: "", dir: "", base: "", ext: "", name: "" };
-        if (path2.length === 0) return ret;
-        var code = path2.charCodeAt(0);
-        var isAbsolute2 = code === 47;
-        var start;
-        if (isAbsolute2) {
-          ret.root = "/";
-          start = 1;
-        } else {
-          start = 0;
-        }
-        var startDot = -1;
-        var startPart = 0;
-        var end = -1;
-        var matchedSlash = true;
-        var i = path2.length - 1;
-        var preDotState = 0;
-        for (; i >= start; --i) {
-          code = path2.charCodeAt(i);
-          if (code === 47) {
-            if (!matchedSlash) {
-              startPart = i + 1;
-              break;
-            }
-            continue;
-          }
-          if (end === -1) {
-            matchedSlash = false;
-            end = i + 1;
-          }
-          if (code === 46) {
-            if (startDot === -1) startDot = i;
-            else if (preDotState !== 1) preDotState = 1;
-          } else if (startDot !== -1) {
-            preDotState = -1;
-          }
-        }
-        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
-        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
-        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-          if (end !== -1) {
-            if (startPart === 0 && isAbsolute2) ret.base = ret.name = path2.slice(1, end);
-            else ret.base = ret.name = path2.slice(startPart, end);
-          }
-        } else {
-          if (startPart === 0 && isAbsolute2) {
-            ret.name = path2.slice(1, startDot);
-            ret.base = path2.slice(1, end);
-          } else {
-            ret.name = path2.slice(startPart, startDot);
-            ret.base = path2.slice(startPart, end);
-          }
-          ret.ext = path2.slice(startDot, end);
-        }
-        if (startPart > 0) ret.dir = path2.slice(0, startPart - 1);
-        else if (isAbsolute2) ret.dir = "/";
-        return ret;
-      },
-      sep: "/",
-      delimiter: ":",
-      win32: null,
-      posix: null
-    };
-    posix.posix = posix;
-    module.exports = posix;
-  }
-});
-
-// src/path.js
-var path = __toESM(require_path_browserify(), 1);
-var import_path_browserify = __toESM(require_path_browserify(), 1);
-var path_default = path;
-var export_basename = import_path_browserify.basename;
-var export_dirname = import_path_browserify.dirname;
-var export_extname = import_path_browserify.extname;
-var export_format = import_path_browserify.format;
-var export_isAbsolute = import_path_browserify.isAbsolute;
-var export_join = import_path_browserify.join;
-var export_normalize = import_path_browserify.normalize;
-var export_parse = import_path_browserify.parse;
-var export_relative = import_path_browserify.relative;
-var export_resolve = import_path_browserify.resolve;
-export {
-  export_basename as basename,
-  path_default as default,
-  export_dirname as dirname,
-  export_extname as extname,
-  export_format as format,
-  export_isAbsolute as isAbsolute,
-  export_join as join,
-  export_normalize as normalize,
-  export_parse as parse,
-  export_relative as relative,
-  export_resolve as resolve
-};
-//# sourceMappingURL=path.mjs.map

dist/lib/node-esm/path.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../../../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js", "../../../src/path.js"],
-  "sourcesContent": ["// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport * as path from 'path-browserify';\n\nexport {\n  resolve,\n  normalize,\n  isAbsolute,\n  join,\n  relative,\n  dirname,\n  basename,\n  extname,\n  format,\n  parse,\n} from 'path-browserify';\nexport default path;\n"],
-  "mappings": ";;;;;;;AAAA;AAAA;AAAA;AA0BA,aAAS,WAAWA,OAAM;AACxB,UAAI,OAAOA,UAAS,UAAU;AAC5B,cAAM,IAAI,UAAU,qCAAqC,KAAK,UAAUA,KAAI,CAAC;AAAA,MAC/E;AAAA,IACF;AAGA,aAAS,qBAAqBA,OAAM,gBAAgB;AAClD,UAAI,MAAM;AACV,UAAI,oBAAoB;AACxB,UAAI,YAAY;AAChB,UAAI,OAAO;AACX,UAAI;AACJ,eAAS,IAAI,GAAG,KAAKA,MAAK,QAAQ,EAAE,GAAG;AACrC,YAAI,IAAIA,MAAK;AACX,iBAAOA,MAAK,WAAW,CAAC;AAAA,iBACjB,SAAS;AAChB;AAAA;AAEA,iBAAO;AACT,YAAI,SAAS,IAAU;AACrB,cAAI,cAAc,IAAI,KAAK,SAAS,GAAG;AAAA,UAEvC,WAAW,cAAc,IAAI,KAAK,SAAS,GAAG;AAC5C,gBAAI,IAAI,SAAS,KAAK,sBAAsB,KAAK,IAAI,WAAW,IAAI,SAAS,CAAC,MAAM,MAAY,IAAI,WAAW,IAAI,SAAS,CAAC,MAAM,IAAU;AAC3I,kBAAI,IAAI,SAAS,GAAG;AAClB,oBAAI,iBAAiB,IAAI,YAAY,GAAG;AACxC,oBAAI,mBAAmB,IAAI,SAAS,GAAG;AACrC,sBAAI,mBAAmB,IAAI;AACzB,0BAAM;AACN,wCAAoB;AAAA,kBACtB,OAAO;AACL,0BAAM,IAAI,MAAM,GAAG,cAAc;AACjC,wCAAoB,IAAI,SAAS,IAAI,IAAI,YAAY,GAAG;AAAA,kBAC1D;AACA,8BAAY;AACZ,yBAAO;AACP;AAAA,gBACF;AAAA,cACF,WAAW,IAAI,WAAW,KAAK,IAAI,WAAW,GAAG;AAC/C,sBAAM;AACN,oCAAoB;AACpB,4BAAY;AACZ,uBAAO;AACP;AAAA,cACF;AAAA,YACF;AACA,gBAAI,gBAAgB;AAClB,kBAAI,IAAI,SAAS;AACf,uBAAO;AAAA;AAEP,sBAAM;AACR,kCAAoB;AAAA,YACtB;AAAA,UACF,OAAO;AACL,gBAAI,IAAI,SAAS;AACf,qBAAO,MAAMA,MAAK,MAAM,YAAY,GAAG,CAAC;AAAA;AAExC,oBAAMA,MAAK,MAAM,YAAY,GAAG,CAAC;AACnC,gCAAoB,IAAI,YAAY;AAAA,UACtC;AACA,sBAAY;AACZ,iBAAO;AAAA,QACT,WAAW,SAAS,MAAY,SAAS,IAAI;AAC3C,YAAE;AAAA,QACJ,OAAO;AACL,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,aAAS,QAAQ,KAAK,YAAY;AAChC,UAAI,MAAM,WAAW,OAAO,WAAW;AACvC,UAAI,OAAO,WAAW,SAAS,WAAW,QAAQ,OAAO,WAAW,OAAO;AAC3E,UAAI,CAAC,KAAK;AACR,eAAO;AAAA,MACT;AACA,UAAI,QAAQ,WAAW,MAAM;AAC3B,eAAO,MAAM;AAAA,MACf;AACA,aAAO,MAAM,MAAM;AAAA,IACrB;AAEA,QAAI,QAAQ;AAAA;AAAA,MAEV,SAAS,SAASC,WAAU;AAC1B,YAAI,eAAe;AACnB,YAAI,mBAAmB;AACvB,YAAI;AAEJ,iBAAS,IAAI,UAAU,SAAS,GAAG,KAAK,MAAM,CAAC,kBAAkB,KAAK;AACpE,cAAID;AACJ,cAAI,KAAK;AACP,YAAAA,QAAO,UAAU,CAAC;AAAA,eACf;AACH,gBAAI,QAAQ;AACV,oBAAM,QAAQ,IAAI;AACpB,YAAAA,QAAO;AAAA,UACT;AAEA,qBAAWA,KAAI;AAGf,cAAIA,MAAK,WAAW,GAAG;AACrB;AAAA,UACF;AAEA,yBAAeA,QAAO,MAAM;AAC5B,6BAAmBA,MAAK,WAAW,CAAC,MAAM;AAAA,QAC5C;AAMA,uBAAe,qBAAqB,cAAc,CAAC,gBAAgB;AAEnE,YAAI,kBAAkB;AACpB,cAAI,aAAa,SAAS;AACxB,mBAAO,MAAM;AAAA;AAEb,mBAAO;AAAA,QACX,WAAW,aAAa,SAAS,GAAG;AAClC,iBAAO;AAAA,QACT,OAAO;AACL,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,MAEA,WAAW,SAASE,WAAUF,OAAM;AAClC,mBAAWA,KAAI;AAEf,YAAIA,MAAK,WAAW,EAAG,QAAO;AAE9B,YAAIG,cAAaH,MAAK,WAAW,CAAC,MAAM;AACxC,YAAI,oBAAoBA,MAAK,WAAWA,MAAK,SAAS,CAAC,MAAM;AAG7D,QAAAA,QAAO,qBAAqBA,OAAM,CAACG,WAAU;AAE7C,YAAIH,MAAK,WAAW,KAAK,CAACG,YAAY,CAAAH,QAAO;AAC7C,YAAIA,MAAK,SAAS,KAAK,kBAAmB,CAAAA,SAAQ;AAElD,YAAIG,YAAY,QAAO,MAAMH;AAC7B,eAAOA;AAAA,MACT;AAAA,MAEA,YAAY,SAASG,YAAWH,OAAM;AACpC,mBAAWA,KAAI;AACf,eAAOA,MAAK,SAAS,KAAKA,MAAK,WAAW,CAAC,MAAM;AAAA,MACnD;AAAA,MAEA,MAAM,SAASI,QAAO;AACpB,YAAI,UAAU,WAAW;AACvB,iBAAO;AACT,YAAI;AACJ,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,EAAE,GAAG;AACzC,cAAI,MAAM,UAAU,CAAC;AACrB,qBAAW,GAAG;AACd,cAAI,IAAI,SAAS,GAAG;AAClB,gBAAI,WAAW;AACb,uBAAS;AAAA;AAET,wBAAU,MAAM;AAAA,UACpB;AAAA,QACF;AACA,YAAI,WAAW;AACb,iBAAO;AACT,eAAO,MAAM,UAAU,MAAM;AAAA,MAC/B;AAAA,MAEA,UAAU,SAASC,UAAS,MAAM,IAAI;AACpC,mBAAW,IAAI;AACf,mBAAW,EAAE;AAEb,YAAI,SAAS,GAAI,QAAO;AAExB,eAAO,MAAM,QAAQ,IAAI;AACzB,aAAK,MAAM,QAAQ,EAAE;AAErB,YAAI,SAAS,GAAI,QAAO;AAGxB,YAAI,YAAY;AAChB,eAAO,YAAY,KAAK,QAAQ,EAAE,WAAW;AAC3C,cAAI,KAAK,WAAW,SAAS,MAAM;AACjC;AAAA,QACJ;AACA,YAAI,UAAU,KAAK;AACnB,YAAI,UAAU,UAAU;AAGxB,YAAI,UAAU;AACd,eAAO,UAAU,GAAG,QAAQ,EAAE,SAAS;AACrC,cAAI,GAAG,WAAW,OAAO,MAAM;AAC7B;AAAA,QACJ;AACA,YAAI,QAAQ,GAAG;AACf,YAAI,QAAQ,QAAQ;AAGpB,YAAI,SAAS,UAAU,QAAQ,UAAU;AACzC,YAAI,gBAAgB;AACpB,YAAI,IAAI;AACR,eAAO,KAAK,QAAQ,EAAE,GAAG;AACvB,cAAI,MAAM,QAAQ;AAChB,gBAAI,QAAQ,QAAQ;AAClB,kBAAI,GAAG,WAAW,UAAU,CAAC,MAAM,IAAU;AAG3C,uBAAO,GAAG,MAAM,UAAU,IAAI,CAAC;AAAA,cACjC,WAAW,MAAM,GAAG;AAGlB,uBAAO,GAAG,MAAM,UAAU,CAAC;AAAA,cAC7B;AAAA,YACF,WAAW,UAAU,QAAQ;AAC3B,kBAAI,KAAK,WAAW,YAAY,CAAC,MAAM,IAAU;AAG/C,gCAAgB;AAAA,cAClB,WAAW,MAAM,GAAG;AAGlB,gCAAgB;AAAA,cAClB;AAAA,YACF;AACA;AAAA,UACF;AACA,cAAI,WAAW,KAAK,WAAW,YAAY,CAAC;AAC5C,cAAI,SAAS,GAAG,WAAW,UAAU,CAAC;AACtC,cAAI,aAAa;AACf;AAAA,mBACO,aAAa;AACpB,4BAAgB;AAAA,QACpB;AAEA,YAAI,MAAM;AAGV,aAAK,IAAI,YAAY,gBAAgB,GAAG,KAAK,SAAS,EAAE,GAAG;AACzD,cAAI,MAAM,WAAW,KAAK,WAAW,CAAC,MAAM,IAAU;AACpD,gBAAI,IAAI,WAAW;AACjB,qBAAO;AAAA;AAEP,qBAAO;AAAA,UACX;AAAA,QACF;AAIA,YAAI,IAAI,SAAS;AACf,iBAAO,MAAM,GAAG,MAAM,UAAU,aAAa;AAAA,aAC1C;AACH,qBAAW;AACX,cAAI,GAAG,WAAW,OAAO,MAAM;AAC7B,cAAE;AACJ,iBAAO,GAAG,MAAM,OAAO;AAAA,QACzB;AAAA,MACF;AAAA,MAEA,WAAW,SAAS,UAAUL,OAAM;AAClC,eAAOA;AAAA,MACT;AAAA,MAEA,SAAS,SAASM,SAAQN,OAAM;AAC9B,mBAAWA,KAAI;AACf,YAAIA,MAAK,WAAW,EAAG,QAAO;AAC9B,YAAI,OAAOA,MAAK,WAAW,CAAC;AAC5B,YAAI,UAAU,SAAS;AACvB,YAAI,MAAM;AACV,YAAI,eAAe;AACnB,iBAAS,IAAIA,MAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACzC,iBAAOA,MAAK,WAAW,CAAC;AACxB,cAAI,SAAS,IAAU;AACnB,gBAAI,CAAC,cAAc;AACjB,oBAAM;AACN;AAAA,YACF;AAAA,UACF,OAAO;AAEP,2BAAe;AAAA,UACjB;AAAA,QACF;AAEA,YAAI,QAAQ,GAAI,QAAO,UAAU,MAAM;AACvC,YAAI,WAAW,QAAQ,EAAG,QAAO;AACjC,eAAOA,MAAK,MAAM,GAAG,GAAG;AAAA,MAC1B;AAAA,MAEA,UAAU,SAASO,UAASP,OAAM,KAAK;AACrC,YAAI,QAAQ,UAAa,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,iCAAiC;AACvG,mBAAWA,KAAI;AAEf,YAAI,QAAQ;AACZ,YAAI,MAAM;AACV,YAAI,eAAe;AACnB,YAAI;AAEJ,YAAI,QAAQ,UAAa,IAAI,SAAS,KAAK,IAAI,UAAUA,MAAK,QAAQ;AACpE,cAAI,IAAI,WAAWA,MAAK,UAAU,QAAQA,MAAM,QAAO;AACvD,cAAI,SAAS,IAAI,SAAS;AAC1B,cAAI,mBAAmB;AACvB,eAAK,IAAIA,MAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACrC,gBAAI,OAAOA,MAAK,WAAW,CAAC;AAC5B,gBAAI,SAAS,IAAU;AAGnB,kBAAI,CAAC,cAAc;AACjB,wBAAQ,IAAI;AACZ;AAAA,cACF;AAAA,YACF,OAAO;AACP,kBAAI,qBAAqB,IAAI;AAG3B,+BAAe;AACf,mCAAmB,IAAI;AAAA,cACzB;AACA,kBAAI,UAAU,GAAG;AAEf,oBAAI,SAAS,IAAI,WAAW,MAAM,GAAG;AACnC,sBAAI,EAAE,WAAW,IAAI;AAGnB,0BAAM;AAAA,kBACR;AAAA,gBACF,OAAO;AAGL,2BAAS;AACT,wBAAM;AAAA,gBACR;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAEA,cAAI,UAAU,IAAK,OAAM;AAAA,mBAA0B,QAAQ,GAAI,OAAMA,MAAK;AAC1E,iBAAOA,MAAK,MAAM,OAAO,GAAG;AAAA,QAC9B,OAAO;AACL,eAAK,IAAIA,MAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACrC,gBAAIA,MAAK,WAAW,CAAC,MAAM,IAAU;AAGjC,kBAAI,CAAC,cAAc;AACjB,wBAAQ,IAAI;AACZ;AAAA,cACF;AAAA,YACF,WAAW,QAAQ,IAAI;AAGvB,6BAAe;AACf,oBAAM,IAAI;AAAA,YACZ;AAAA,UACF;AAEA,cAAI,QAAQ,GAAI,QAAO;AACvB,iBAAOA,MAAK,MAAM,OAAO,GAAG;AAAA,QAC9B;AAAA,MACF;AAAA,MAEA,SAAS,SAASQ,SAAQR,OAAM;AAC9B,mBAAWA,KAAI;AACf,YAAI,WAAW;AACf,YAAI,YAAY;AAChB,YAAI,MAAM;AACV,YAAI,eAAe;AAGnB,YAAI,cAAc;AAClB,iBAAS,IAAIA,MAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACzC,cAAI,OAAOA,MAAK,WAAW,CAAC;AAC5B,cAAI,SAAS,IAAU;AAGnB,gBAAI,CAAC,cAAc;AACjB,0BAAY,IAAI;AAChB;AAAA,YACF;AACA;AAAA,UACF;AACF,cAAI,QAAQ,IAAI;AAGd,2BAAe;AACf,kBAAM,IAAI;AAAA,UACZ;AACA,cAAI,SAAS,IAAU;AAEnB,gBAAI,aAAa;AACf,yBAAW;AAAA,qBACJ,gBAAgB;AACvB,4BAAc;AAAA,UACpB,WAAW,aAAa,IAAI;AAG1B,0BAAc;AAAA,UAChB;AAAA,QACF;AAEA,YAAI,aAAa,MAAM,QAAQ;AAAA,QAE3B,gBAAgB;AAAA,QAEhB,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GAAG;AAC3E,iBAAO;AAAA,QACT;AACA,eAAOA,MAAK,MAAM,UAAU,GAAG;AAAA,MACjC;AAAA,MAEA,QAAQ,SAASS,QAAO,YAAY;AAClC,YAAI,eAAe,QAAQ,OAAO,eAAe,UAAU;AACzD,gBAAM,IAAI,UAAU,qEAAqE,OAAO,UAAU;AAAA,QAC5G;AACA,eAAO,QAAQ,KAAK,UAAU;AAAA,MAChC;AAAA,MAEA,OAAO,SAASC,OAAMV,OAAM;AAC1B,mBAAWA,KAAI;AAEf,YAAI,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,MAAM,GAAG;AAC3D,YAAIA,MAAK,WAAW,EAAG,QAAO;AAC9B,YAAI,OAAOA,MAAK,WAAW,CAAC;AAC5B,YAAIG,cAAa,SAAS;AAC1B,YAAI;AACJ,YAAIA,aAAY;AACd,cAAI,OAAO;AACX,kBAAQ;AAAA,QACV,OAAO;AACL,kBAAQ;AAAA,QACV;AACA,YAAI,WAAW;AACf,YAAI,YAAY;AAChB,YAAI,MAAM;AACV,YAAI,eAAe;AACnB,YAAI,IAAIH,MAAK,SAAS;AAItB,YAAI,cAAc;AAGlB,eAAO,KAAK,OAAO,EAAE,GAAG;AACtB,iBAAOA,MAAK,WAAW,CAAC;AACxB,cAAI,SAAS,IAAU;AAGnB,gBAAI,CAAC,cAAc;AACjB,0BAAY,IAAI;AAChB;AAAA,YACF;AACA;AAAA,UACF;AACF,cAAI,QAAQ,IAAI;AAGd,2BAAe;AACf,kBAAM,IAAI;AAAA,UACZ;AACA,cAAI,SAAS,IAAU;AAEnB,gBAAI,aAAa,GAAI,YAAW;AAAA,qBAAW,gBAAgB,EAAG,eAAc;AAAA,UAC9E,WAAW,aAAa,IAAI;AAG5B,0BAAc;AAAA,UAChB;AAAA,QACF;AAEA,YAAI,aAAa,MAAM,QAAQ;AAAA,QAE/B,gBAAgB;AAAA,QAEhB,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GAAG;AACvE,cAAI,QAAQ,IAAI;AACd,gBAAI,cAAc,KAAKG,YAAY,KAAI,OAAO,IAAI,OAAOH,MAAK,MAAM,GAAG,GAAG;AAAA,gBAAO,KAAI,OAAO,IAAI,OAAOA,MAAK,MAAM,WAAW,GAAG;AAAA,UAClI;AAAA,QACF,OAAO;AACL,cAAI,cAAc,KAAKG,aAAY;AACjC,gBAAI,OAAOH,MAAK,MAAM,GAAG,QAAQ;AACjC,gBAAI,OAAOA,MAAK,MAAM,GAAG,GAAG;AAAA,UAC9B,OAAO;AACL,gBAAI,OAAOA,MAAK,MAAM,WAAW,QAAQ;AACzC,gBAAI,OAAOA,MAAK,MAAM,WAAW,GAAG;AAAA,UACtC;AACA,cAAI,MAAMA,MAAK,MAAM,UAAU,GAAG;AAAA,QACpC;AAEA,YAAI,YAAY,EAAG,KAAI,MAAMA,MAAK,MAAM,GAAG,YAAY,CAAC;AAAA,iBAAWG,YAAY,KAAI,MAAM;AAEzF,eAAO;AAAA,MACT;AAAA,MAEA,KAAK;AAAA,MACL,WAAW;AAAA,MACX,OAAO;AAAA,MACP,OAAO;AAAA,IACT;AAEA,UAAM,QAAQ;AAEd,WAAO,UAAU;AAAA;AAAA;;;AC5gBjB,WAAsB;AAEtB,6BAWO;AACP,IAAO,eAAQ;",
-  "names": ["path", "resolve", "normalize", "isAbsolute", "join", "relative", "dirname", "basename", "extname", "format", "parse"]
-}

dist/lib/node-esm/stream.mjs

-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-RZY7P3LC.mjs";
-
-// src/stream.js
-import { Duplex, PassThrough, pipeline, Stream, Transform, Readable, Writable } from "readable-stream";
-export {
-  Duplex,
-  PassThrough,
-  Readable,
-  Stream,
-  Transform,
-  Writable,
-  pipeline
-};
-//# sourceMappingURL=stream.mjs.map

dist/lib/node-esm/stream.mjs.map

-{
-  "version": 3,
-  "sources": ["../../../src/stream.js"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nexport { Duplex, PassThrough, pipeline, Stream, Transform, Readable, Writable } from 'readable-stream';\n"],
-  "mappings": ";;;;AAIA,SAAS,QAAQ,aAAa,UAAU,QAAQ,WAAW,UAAU,gBAAgB;",
-  "names": []
-}

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

No repository

Supply chain risk

Package does not have a linked source code repository. Without this field, a package will have no reference to the location of the source code use to generate the package.

Found 1 instance in 1 package

Improved metrics

Number of low supply chain risk alerts

11

-52.17%

Number of medium supply chain risk alerts

4

-42.86%

Worsened metrics

Total package byte prevSize

783419

-38.03%

Number of package files

54

-26.03%

Lines of code

7315

-39.47%

No dependency changes