@powerlines/deepkit 0.5.0 → 0.5.2

package/dist/vendor/type.js

@@ -1,21 +1,1572 @@
-import { empty, __ΩAbstractClassType as ___AbstractClassType, __ΩClassType as ___ClassType, isFunction, stringifyValueWithType, isClass, isArray, getClassName, isPrototypeOfBase, arrayRemoveItem, indent, getParentClass, CustomError, CompilerContext, __ΩExtractClassType as ___ExtractClassType, isGlobalClass, getInheritanceChain, isObject, toFastProperties, isNumeric, hasProperty, isObjectLiteral, isIterable, iterableSize, getClassTypeFromInstance, __ΩTypeAnnotation as ___TypeAnnotation, getObjectKeysSize, isInteger } from '../chunk-4WJJKR53.js';
-import { ReflectionOp, TypeNumberBrand } from '../chunk-7WAH4JD3.js';
-export { TypeNumberBrand } from '../chunk-7WAH4JD3.js';
-import { init_esm_shims, __name } from '../chunk-QQ7GKXIS.js';
-import { Buffer } from 'buffer';
-import crypto from 'crypto';
+import { empty, __ΩAbstractClassType as ___AbstractClassType, __ΩClassType as ___ClassType, isFunction, stringifyValueWithType, isClass, isArray, getClassName, isPrototypeOfBase, arrayRemoveItem, indent, getParentClass, CustomError, CompilerContext, __ΩExtractClassType as ___ExtractClassType, isGlobalClass, getInheritanceChain, isObject, toFastProperties, isNumeric, hasProperty, isObjectLiteral, isIterable, iterableSize, getClassTypeFromInstance, __ΩTypeAnnotation as ___TypeAnnotation, getObjectKeysSize, isInteger } from './chunk-BLN7QVCP.js';
+import { ReflectionOp, TypeNumberBrand } from './chunk-BR2FK5K7.js';
+export { TypeNumberBrand } from './chunk-BR2FK5K7.js';
+import { __commonJS, __name, __toESM } from './chunk-5BKT4CS5.js';
 
-// src/vendor/type.ts
-init_esm_shims();
+// ../../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$1) {
+    exports$1.byteLength = byteLength;
+    exports$1.toByteArray = toByteArray;
+    exports$1.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
+      ];
+    }
+    __name(getLens, "getLens");
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    __name(byteLength, "byteLength");
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    __name(_byteLength, "_byteLength");
+    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;
+    }
+    __name(toByteArray, "toByteArray");
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    __name(tripletToBase64, "tripletToBase64");
+    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("");
+    }
+    __name(encodeChunk, "encodeChunk");
+    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("");
+    }
+    __name(fromByteArray, "fromByteArray");
+  }
+});
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/index.js
-init_esm_shims();
+// ../../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$1) {
+    exports$1.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$1.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/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/change-detector.js
-init_esm_shims();
+// ../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js"(exports$1) {
+    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$1.Buffer = Buffer2;
+    exports$1.SlowBuffer = SlowBuffer;
+    exports$1.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports$1.kMaxLength = K_MAX_LENGTH;
+    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer2.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 {
+        var arr = new Uint8Array(1);
+        var proto = {
+          foo: /* @__PURE__ */ __name(function() {
+            return 42;
+          }, "foo")
+        };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(typedArraySupport, "typedArraySupport");
+    Object.defineProperty(Buffer2.prototype, "parent", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        if (!Buffer2.isBuffer(this)) return void 0;
+        return this.buffer;
+      }, "get")
+    });
+    Object.defineProperty(Buffer2.prototype, "offset", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        if (!Buffer2.isBuffer(this)) return void 0;
+        return this.byteOffset;
+      }, "get")
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length + '" is invalid for option "size"');
+      }
+      var buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer2.prototype);
+      return buf;
+    }
+    __name(createBuffer, "createBuffer");
+    function Buffer2(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);
+    }
+    __name(Buffer2, "Buffer");
+    Buffer2.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');
+      }
+      var valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer2.from(valueOf, encodingOrOffset, length);
+      }
+      var b = fromObject(value);
+      if (b) return b;
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer2.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);
+    }
+    __name(from, "from");
+    Buffer2.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer2, 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"');
+      }
+    }
+    __name(assertSize, "assertSize");
+    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);
+    }
+    __name(alloc, "alloc");
+    Buffer2.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    __name(allocUnsafe, "allocUnsafe");
+    Buffer2.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer2.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer2.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      var length = byteLength(string, encoding) | 0;
+      var buf = createBuffer(length);
+      var actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    __name(fromString, "fromString");
+    function fromArrayLike(array) {
+      var length = array.length < 0 ? 0 : checked(array.length) | 0;
+      var buf = createBuffer(length);
+      for (var i = 0; i < length; i += 1) {
+        buf[i] = array[i] & 255;
+      }
+      return buf;
+    }
+    __name(fromArrayLike, "fromArrayLike");
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        var copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    __name(fromArrayView, "fromArrayView");
+    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');
+      }
+      var 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, Buffer2.prototype);
+      return buf;
+    }
+    __name(fromArrayBuffer, "fromArrayBuffer");
+    function fromObject(obj) {
+      if (Buffer2.isBuffer(obj)) {
+        var len = checked(obj.length) | 0;
+        var 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);
+      }
+    }
+    __name(fromObject, "fromObject");
+    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;
+    }
+    __name(checked, "checked");
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer2.alloc(+length);
+    }
+    __name(SlowBuffer, "SlowBuffer");
+    Buffer2.isBuffer = /* @__PURE__ */ __name(function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+    }, "isBuffer");
+    Buffer2.compare = /* @__PURE__ */ __name(function compare(a, b) {
+      if (isInstance(a, Uint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);
+      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+        throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+      }
+      if (a === b) return 0;
+      var x = a.length;
+      var y = b.length;
+      for (var 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;
+    }, "compare");
+    Buffer2.isEncoding = /* @__PURE__ */ __name(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;
+      }
+    }, "isEncoding");
+    Buffer2.concat = /* @__PURE__ */ __name(function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer2.alloc(0);
+      }
+      var i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      var buffer = Buffer2.allocUnsafe(length);
+      var pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        var buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            Buffer2.from(buf).copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(buffer, buf, pos);
+          }
+        } else if (!Buffer2.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    }, "concat");
+    function byteLength(string, encoding) {
+      if (Buffer2.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);
+      }
+      var len = string.length;
+      var mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0) return 0;
+      var 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;
+        }
+      }
+    }
+    __name(byteLength, "byteLength");
+    Buffer2.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      var 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;
+        }
+      }
+    }
+    __name(slowToString, "slowToString");
+    Buffer2.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      var i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    __name(swap, "swap");
+    Buffer2.prototype.swap16 = /* @__PURE__ */ __name(function swap16() {
+      var len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (var i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    }, "swap16");
+    Buffer2.prototype.swap32 = /* @__PURE__ */ __name(function swap32() {
+      var len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (var i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    }, "swap32");
+    Buffer2.prototype.swap64 = /* @__PURE__ */ __name(function swap64() {
+      var len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      for (var 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;
+    }, "swap64");
+    Buffer2.prototype.toString = /* @__PURE__ */ __name(function toString() {
+      var length = this.length;
+      if (length === 0) return "";
+      if (arguments.length === 0) return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    }, "toString");
+    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+    Buffer2.prototype.equals = /* @__PURE__ */ __name(function equals(b) {
+      if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer2.compare(this, b) === 0;
+    }, "equals");
+    Buffer2.prototype.inspect = /* @__PURE__ */ __name(function inspect() {
+      var str = "";
+      var max = exports$1.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max) str += " ... ";
+      return "<Buffer " + str + ">";
+    }, "inspect");
+    if (customInspectSymbol) {
+      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+    }
+    Buffer2.prototype.compare = /* @__PURE__ */ __name(function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer2.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer2.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;
+      var x = thisEnd - thisStart;
+      var y = end - start;
+      var len = Math.min(x, y);
+      var thisCopy = this.slice(thisStart, thisEnd);
+      var targetCopy = target.slice(start, end);
+      for (var 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;
+    }, "compare");
+    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 = Buffer2.from(val, encoding);
+      }
+      if (Buffer2.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");
+    }
+    __name(bidirectionalIndexOf, "bidirectionalIndexOf");
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      var indexSize = 1;
+      var arrLength = arr.length;
+      var 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);
+        }
+      }
+      __name(read, "read");
+      var i;
+      if (dir) {
+        var 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--) {
+          var found = true;
+          for (var j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    __name(arrayIndexOf, "arrayIndexOf");
+    Buffer2.prototype.includes = /* @__PURE__ */ __name(function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    }, "includes");
+    Buffer2.prototype.indexOf = /* @__PURE__ */ __name(function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    }, "indexOf");
+    Buffer2.prototype.lastIndexOf = /* @__PURE__ */ __name(function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    }, "lastIndexOf");
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      var remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      var strLen = string.length;
+      if (length > strLen / 2) {
+        length = strLen / 2;
+      }
+      for (var i = 0; i < length; ++i) {
+        var parsed = parseInt(string.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed)) return i;
+        buf[offset + i] = parsed;
+      }
+      return i;
+    }
+    __name(hexWrite, "hexWrite");
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    __name(utf8Write, "utf8Write");
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    __name(asciiWrite, "asciiWrite");
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    __name(base64Write, "base64Write");
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    __name(ucs2Write, "ucs2Write");
+    Buffer2.prototype.write = /* @__PURE__ */ __name(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");
+      }
+      var 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";
+      var 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;
+        }
+      }
+    }, "write");
+    Buffer2.prototype.toJSON = /* @__PURE__ */ __name(function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    }, "toJSON");
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    __name(base64Slice, "base64Slice");
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      var res = [];
+      var i = start;
+      while (i < end) {
+        var firstByte = buf[i];
+        var codePoint = null;
+        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          var 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);
+    }
+    __name(utf8Slice, "utf8Slice");
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      var len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      var res = "";
+      var i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+      }
+      return res;
+    }
+    __name(decodeCodePointsArray, "decodeCodePointsArray");
+    function asciiSlice(buf, start, end) {
+      var ret = "";
+      end = Math.min(buf.length, end);
+      for (var i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i] & 127);
+      }
+      return ret;
+    }
+    __name(asciiSlice, "asciiSlice");
+    function latin1Slice(buf, start, end) {
+      var ret = "";
+      end = Math.min(buf.length, end);
+      for (var i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i]);
+      }
+      return ret;
+    }
+    __name(latin1Slice, "latin1Slice");
+    function hexSlice(buf, start, end) {
+      var len = buf.length;
+      if (!start || start < 0) start = 0;
+      if (!end || end < 0 || end > len) end = len;
+      var out = "";
+      for (var i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf[i]];
+      }
+      return out;
+    }
+    __name(hexSlice, "hexSlice");
+    function utf16leSlice(buf, start, end) {
+      var bytes = buf.slice(start, end);
+      var res = "";
+      for (var i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    __name(utf16leSlice, "utf16leSlice");
+    Buffer2.prototype.slice = /* @__PURE__ */ __name(function slice(start, end) {
+      var 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;
+      var newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer2.prototype);
+      return newBuf;
+    }, "slice");
+    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");
+    }
+    __name(checkOffset, "checkOffset");
+    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = /* @__PURE__ */ __name(function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      var val = this[offset];
+      var mul = 1;
+      var i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      return val;
+    }, "readUIntLE");
+    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = /* @__PURE__ */ __name(function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      var val = this[offset + --byteLength2];
+      var mul = 1;
+      while (byteLength2 > 0 && (mul *= 256)) {
+        val += this[offset + --byteLength2] * mul;
+      }
+      return val;
+    }, "readUIntBE");
+    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = /* @__PURE__ */ __name(function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      return this[offset];
+    }, "readUInt8");
+    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = /* @__PURE__ */ __name(function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    }, "readUInt16LE");
+    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = /* @__PURE__ */ __name(function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    }, "readUInt16BE");
+    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = /* @__PURE__ */ __name(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;
+    }, "readUInt32LE");
+    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = /* @__PURE__ */ __name(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]);
+    }, "readUInt32BE");
+    Buffer2.prototype.readIntLE = /* @__PURE__ */ __name(function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      var val = this[offset];
+      var mul = 1;
+      var 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;
+    }, "readIntLE");
+    Buffer2.prototype.readIntBE = /* @__PURE__ */ __name(function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      var i = byteLength2;
+      var mul = 1;
+      var 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;
+    }, "readIntBE");
+    Buffer2.prototype.readInt8 = /* @__PURE__ */ __name(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;
+    }, "readInt8");
+    Buffer2.prototype.readInt16LE = /* @__PURE__ */ __name(function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      var val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    }, "readInt16LE");
+    Buffer2.prototype.readInt16BE = /* @__PURE__ */ __name(function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      var val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    }, "readInt16BE");
+    Buffer2.prototype.readInt32LE = /* @__PURE__ */ __name(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;
+    }, "readInt32LE");
+    Buffer2.prototype.readInt32BE = /* @__PURE__ */ __name(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];
+    }, "readInt32BE");
+    Buffer2.prototype.readFloatLE = /* @__PURE__ */ __name(function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    }, "readFloatLE");
+    Buffer2.prototype.readFloatBE = /* @__PURE__ */ __name(function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    }, "readFloatBE");
+    Buffer2.prototype.readDoubleLE = /* @__PURE__ */ __name(function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    }, "readDoubleLE");
+    Buffer2.prototype.readDoubleBE = /* @__PURE__ */ __name(function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    }, "readDoubleBE");
+    function checkInt(buf, value, offset, ext, max, min) {
+      if (!Buffer2.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");
+    }
+    __name(checkInt, "checkInt");
+    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = /* @__PURE__ */ __name(function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      var mul = 1;
+      var i = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    }, "writeUIntLE");
+    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = /* @__PURE__ */ __name(function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      var i = byteLength2 - 1;
+      var mul = 1;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    }, "writeUIntBE");
+    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = /* @__PURE__ */ __name(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;
+    }, "writeUInt8");
+    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = /* @__PURE__ */ __name(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;
+    }, "writeUInt16LE");
+    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = /* @__PURE__ */ __name(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;
+    }, "writeUInt16BE");
+    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = /* @__PURE__ */ __name(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;
+    }, "writeUInt32LE");
+    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = /* @__PURE__ */ __name(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;
+    }, "writeUInt32BE");
+    Buffer2.prototype.writeIntLE = /* @__PURE__ */ __name(function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      var i = 0;
+      var mul = 1;
+      var 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;
+    }, "writeIntLE");
+    Buffer2.prototype.writeIntBE = /* @__PURE__ */ __name(function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      var i = byteLength2 - 1;
+      var mul = 1;
+      var 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;
+    }, "writeIntBE");
+    Buffer2.prototype.writeInt8 = /* @__PURE__ */ __name(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;
+    }, "writeInt8");
+    Buffer2.prototype.writeInt16LE = /* @__PURE__ */ __name(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;
+    }, "writeInt16LE");
+    Buffer2.prototype.writeInt16BE = /* @__PURE__ */ __name(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;
+    }, "writeInt16BE");
+    Buffer2.prototype.writeInt32LE = /* @__PURE__ */ __name(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;
+    }, "writeInt32LE");
+    Buffer2.prototype.writeInt32BE = /* @__PURE__ */ __name(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;
+    }, "writeInt32BE");
+    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");
+    }
+    __name(checkIEEE754, "checkIEEE754");
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 4);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    __name(writeFloat, "writeFloat");
+    Buffer2.prototype.writeFloatLE = /* @__PURE__ */ __name(function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    }, "writeFloatLE");
+    Buffer2.prototype.writeFloatBE = /* @__PURE__ */ __name(function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
+    }, "writeFloatBE");
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 8);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    __name(writeDouble, "writeDouble");
+    Buffer2.prototype.writeDoubleLE = /* @__PURE__ */ __name(function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    }, "writeDoubleLE");
+    Buffer2.prototype.writeDoubleBE = /* @__PURE__ */ __name(function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    }, "writeDoubleBE");
+    Buffer2.prototype.copy = /* @__PURE__ */ __name(function copy(target, targetStart, start, end) {
+      if (!Buffer2.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;
+      }
+      var 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;
+    }, "copy");
+    Buffer2.prototype.fill = /* @__PURE__ */ __name(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" && !Buffer2.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          var 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;
+      var i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+        var 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;
+    }, "fill");
+    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;
+    }
+    __name(base64clean, "base64clean");
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      var codePoint;
+      var length = string.length;
+      var leadSurrogate = null;
+      var bytes = [];
+      for (var 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;
+    }
+    __name(utf8ToBytes, "utf8ToBytes");
+    function asciiToBytes(str) {
+      var byteArray = [];
+      for (var i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    __name(asciiToBytes, "asciiToBytes");
+    function utf16leToBytes(str, units) {
+      var c, hi, lo;
+      var byteArray = [];
+      for (var 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;
+    }
+    __name(utf16leToBytes, "utf16leToBytes");
+    function base64ToBytes(str) {
+      return base64.toByteArray(base64clean(str));
+    }
+    __name(base64ToBytes, "base64ToBytes");
+    function blitBuffer(src, dst, offset, length) {
+      for (var i = 0; i < length; ++i) {
+        if (i + offset >= dst.length || i >= src.length) break;
+        dst[i + offset] = src[i];
+      }
+      return i;
+    }
+    __name(blitBuffer, "blitBuffer");
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    __name(isInstance, "isInstance");
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    __name(numberIsNaN, "numberIsNaN");
+    var hexSliceLookupTable = (function() {
+      var alphabet = "0123456789abcdef";
+      var table = new Array(256);
+      for (var i = 0; i < 16; ++i) {
+        var i16 = i * 16;
+        for (var j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table;
+    })();
+  }
+});
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/changes.js
-init_esm_shims();
 var __\u03A9Pick = [
   "T",
   "K",
@@ -256,20 +1807,7 @@ atomicChange.__type = [
   'P"2!"/"'
 ];
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/snapshot.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reflection/type.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reflection/reflection.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reflection/processor.js
-init_esm_shims();
-
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/debug.js
-init_esm_shims();
 function isDebug(level = 1) {
   const expected = "deepkit" + (level > 1 ? "+".repeat(level - 1) : "");
   return "undefined" !== typeof process && "string" === typeof process.env.DEBUG && process.env.DEBUG.includes(expected);
@@ -304,11 +1842,7 @@ debug2.__type = [
   'P"@2!$/"'
 ];
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/decorator.js
-init_esm_shims();
-
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/decorator-builder.js
-init_esm_shims();
 var __\u03A9Omit = [
   "T",
   "K",
@@ -952,7 +2486,7 @@ isDecoratorContext.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/core.js
-init_esm_shims();
+var import_buffer = __toESM(require_buffer(), 1);
 var __\u03A9ArrayBufferLike = [
   () => __\u03A9ArrayBufferTypes,
   () => __\u03A9ArrayBufferTypes,
@@ -1013,7 +2547,7 @@ function nodeBufferToTypedArray(buf, type) {
 }
 __name(nodeBufferToTypedArray, "nodeBufferToTypedArray");
 nodeBufferToTypedArray.__type = [
-  () => Buffer,
+  () => import_buffer.Buffer,
   "buf",
   () => __\u03A9TypedArrayClassType,
   "type",
@@ -1039,7 +2573,7 @@ function base64ToTypedArray(base64, type) {
   if ("function" === typeof atob) {
     return new type(base64ToUint8ArrayAtoB(base64).buffer);
   }
-  return nodeBufferToTypedArray(Buffer.from(base64, "base64"), type);
+  return nodeBufferToTypedArray(import_buffer.Buffer.from(base64, "base64"), type);
 }
 __name(base64ToTypedArray, "base64ToTypedArray");
 base64ToTypedArray.__type = [
@@ -1053,7 +2587,7 @@ function base64ToArrayBuffer(base64) {
   if ("function" === typeof atob) {
     return base64ToUint8ArrayAtoB(base64).buffer;
   }
-  return nodeBufferToArrayBuffer(Buffer.from(base64, "base64"));
+  return nodeBufferToArrayBuffer(import_buffer.Buffer.from(base64, "base64"));
 }
 __name(base64ToArrayBuffer, "base64ToArrayBuffer");
 base64ToArrayBuffer.__type = [
@@ -1072,19 +2606,19 @@ nodeBufferToArrayBuffer.__type = [
   'PPW_J2!_/"'
 ];
 function typedArrayToBuffer(typedArray) {
-  if (typedArray instanceof Buffer) return typedArray;
-  return Buffer.from(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+  if (typedArray instanceof import_buffer.Buffer) return typedArray;
+  return import_buffer.Buffer.from(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
 }
 __name(typedArrayToBuffer, "typedArrayToBuffer");
 typedArrayToBuffer.__type = [
   () => __\u03A9TypedArray,
   "typedArray",
-  () => Buffer,
+  () => import_buffer.Buffer,
   "typedArrayToBuffer",
   'Pn!2"P7#/$'
 ];
 function arrayBufferToBase64(arrayBuffer) {
-  return Buffer.from(arrayBuffer).toString("base64");
+  return import_buffer.Buffer.from(arrayBuffer).toString("base64");
 }
 __name(arrayBufferToBase64, "arrayBufferToBase64");
 arrayBufferToBase64.__type = [
@@ -1103,7 +2637,7 @@ typedArrayToBase64.__type = [
   'Pn!2"&/#'
 ];
 function arrayBufferFrom(data, encoding) {
-  return nodeBufferToArrayBuffer(Buffer.from(data, encoding));
+  return nodeBufferToArrayBuffer(import_buffer.Buffer.from(data, encoding));
 }
 __name(arrayBufferFrom, "arrayBufferFrom");
 arrayBufferFrom.__type = [
@@ -1113,7 +2647,7 @@ arrayBufferFrom.__type = [
   'P&2!&2"8_/#'
 ];
 function arrayBufferTo(arrayBuffer, encoding) {
-  return Buffer.from(arrayBuffer).toString(encoding);
+  return import_buffer.Buffer.from(arrayBuffer).toString(encoding);
 }
 __name(arrayBufferTo, "arrayBufferTo");
 arrayBufferTo.__type = [
@@ -1303,7 +2837,6 @@ addDeferredDecorator.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reflection/extends.js
-init_esm_shims();
 function __assignType2(fn, args) {
   fn.__type = args;
   return fn;
@@ -2046,7 +3579,6 @@ inferFromTuple.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reflection/state.js
-init_esm_shims();
 var state = {
   nominalId: 1
 };
@@ -4449,7 +5981,6 @@ resolveFunction.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/inheritance.js
-init_esm_shims();
 function findCommonLiteral(reflectionClasses) {
   const candidates = {};
   for (const schema of reflectionClasses) {
@@ -4492,52 +6023,39 @@ findCommonLiteral.__type = [
   'PP"7!F2"P&-J/#'
 ];
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/type-serialization.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/utils.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/index.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/rng.js
-init_esm_shims();
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
+// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-browser/rng.js
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
 function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    crypto.randomFillSync(rnds8Pool);
-    poolPtr = 0;
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== "undefined" && typeof msCrypto.getRandomValues === "function" && msCrypto.getRandomValues.bind(msCrypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
   }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+  return getRandomValues(rnds8);
 }
 __name(rng, "rng");
 
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/stringify.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/validate.js
-init_esm_shims();
-
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/regex.js
-init_esm_shims();
+// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-browser/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
 
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/validate.js
+// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-browser/validate.js
 function validate(uuid2) {
   return typeof uuid2 === "string" && regex_default.test(uuid2);
 }
 __name(validate, "validate");
 var validate_default = validate;
 
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/stringify.js
+// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-browser/stringify.js
 var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
+for (i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).substr(1));
 }
-function stringify(arr, offset = 0) {
-  const uuid2 = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+var i;
+function stringify(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  var uuid2 = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
   if (!validate_default(uuid2)) {
     throw TypeError("Stringified UUID is invalid");
   }
@@ -4546,16 +6064,15 @@ function stringify(arr, offset = 0) {
 __name(stringify, "stringify");
 var stringify_default = stringify;
 
-// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-node/v4.js
-init_esm_shims();
+// ../../node_modules/.pnpm/uuid@8.3.2/node_modules/uuid/dist/esm-browser/v4.js
 function v4(options, buf, offset) {
   options = options || {};
-  const rnds = options.random || (options.rng || rng)();
+  var rnds = options.random || (options.rng || rng)();
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
     offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
+    for (var i = 0; i < 16; ++i) {
       buf[offset + i] = rnds[i];
     }
     return buf;
@@ -11169,11 +12686,7 @@ annotateClass.__type = [
   'PPn!n"J2#"o$"2%8"/&'
 ];
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/serializer.js
-init_esm_shims();
-
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/reference.js
-init_esm_shims();
 function __assignType7(fn, args) {
   fn.__type = args;
   return fn;
@@ -11363,11 +12876,7 @@ createReferenceClass.__type = [
   'PP"7!2""o#"/$'
 ];
 
-// ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/validator.js
-init_esm_shims();
-
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/typeguard.js
-init_esm_shims();
 function __assignType8(fn, args) {
   fn.__type = args;
   return fn;
@@ -11815,7 +13324,6 @@ validates.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/validators.js
-init_esm_shims();
 function __assignType10(fn, args) {
   fn.__type = args;
   return fn;
@@ -16104,7 +17612,6 @@ buildChanges.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/default.js
-init_esm_shims();
 function defaultValue(type) {
   switch (type.kind) {
     case ReflectionKind.void:
@@ -16207,7 +17714,6 @@ defaultValue.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/mixin.js
-init_esm_shims();
 function __assignType14(fn, args) {
   fn.__type = args;
   return fn;
@@ -16272,7 +17778,6 @@ mixin.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/path.js
-init_esm_shims();
 var __\u03A9Resolver = [
   "path",
   "Type",
@@ -16413,7 +17918,6 @@ pathResolver.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/registry.js
-init_esm_shims();
 var __\u03A9RegistryDecorator = [
   "T",
   "Type",
@@ -16548,7 +18052,6 @@ TypeRegistry.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/serializer-facade.js
-init_esm_shims();
 function __assignType15(fn, args) {
   fn.__type = args;
   return fn;
@@ -16832,7 +18335,6 @@ validatedDeserialize.__type = [
 ];
 
 // ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b2d2ba2e4ddca11757d65b5c17ef456439accd6f1b86325f0a81d5ff_9c5066bcad2b41c430f9fe2a690de22b/node_modules/@deepkit/type/dist/esm/src/types.js
-init_esm_shims();
 var __\u03A9AutoId = [
   () => __\u03A9PrimaryKey,
   () => __\u03A9AutoIncrement,
@@ -16840,5 +18342,18 @@ var __\u03A9AutoId = [
   "AutoId",
   `P'n!n"n#Kw$y`
 ];
+/*! 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
+   *)
+*/
 
 export { AnnotationDefinition, AtomicChangeInstance, CartesianProduct, Changes, ContainerAccessor, EMAIL_REGEX, EmptySerializer, EntityData, ItemChanges, JitStack, NamingStrategy, NoTypeReceived, PackStruct, Processor, ReflectionClass, ReflectionFunction, ReflectionKind, ReflectionMethod, ReflectionParameter, ReflectionProperty, ReflectionVisibility, RuntimeCode, SerializationError, Serializer, TData, TemplateRegistry, TemplateState, TypeGuardRegistry, TypeRegistry, UUIDAnnotation, UnpopulatedCheck, ValidationError, ValidationErrorItem, ValidatorError, __ΩAPIClass, __ΩAPIProperty, __ΩAfterDate, __ΩAfterNow, __ΩAlpha, __ΩAlphanumeric, __ΩAnnotationType, __ΩAnnotations, __ΩAscii, __ΩAutoId, __ΩAutoIncrement, __ΩBackReference, __ΩBackReferenceOptions, __ΩBackReferenceOptionsResolved, __ΩBeforeDate, __ΩBeforeNow, __ΩBinary, __ΩBinaryBigInt, __ΩBinaryBigIntType, __ΩChangesInterface, __ΩClassApiTypeInterface, __ΩClassDecoratorFn, __ΩClassDecoratorResult, __ΩData, __ΩDatabaseField, __ΩDatabaseFieldOptions, __ΩDecimal, __ΩDecoratorAndFetchSignature, __ΩDeepPartial, __ΩDualDecorator, __ΩEmail, __ΩEmbedded, __ΩEmbeddedMeta, __ΩEmbeddedOptions, __ΩEntity, __ΩEntityOptions, __ΩExcluded, __ΩExcludes, __ΩExclusiveMaximum, __ΩExclusiveMinimum, __ΩExpression, __ΩExtractApiDataType, __ΩExtractClass, __ΩFindType, __ΩFluidDecorator, __ΩFreeDecoratorFn, __ΩFreeDecoratorResult, __ΩFreeFluidDecorator, __ΩGroup, __ΩGuard, __ΩIncludes, __ΩIndex, __ΩIndexOptions, __ΩInlineRuntimeType, __ΩJSONEntity, __ΩJSONPartial, __ΩJSONPartialObject, __ΩJSONSingle, __ΩJitContainer, __ΩMapName, __ΩMaxLength, __ΩMaximum, __ΩMerge, __ΩMinLength, __ΩMinimum, __ΩMongoId, __ΩMultipleOf, __ΩMySQL, __ΩMySQLOptions, __ΩNegative, __ΩNegativeNoZero, __ΩNumberFields, __ΩPacked, __ΩParentLessType, __ΩPartial, __ΩPattern, __ΩPositive, __ΩPositiveNoZero, __ΩPostgres, __ΩPostgresOptions, __ΩPrimaryKey, __ΩPrimaryKeyFields, __ΩPrimaryKeyType, __ΩPropertyApiTypeInterface, __ΩPropertyDecoratorFn, __ΩPropertyDecoratorResult, __ΩReceiveType, __ΩReference, __ΩReferenceActions, __ΩReferenceFields, __ΩReferenceInfo, __ΩReferenceItemInfo, __ΩReferenceOptions, __ΩReflectOptions, __ΩReflectionKind, __ΩReflectionVisibility, __ΩResetAnnotation, __ΩResolver, __ΩRuntimeStackEntry, __ΩSQLite, __ΩSerializationOptions, __ΩSerializeFunction, __ΩSerializedType, __ΩSerializedTypeAnnotations, __ΩSerializedTypeArray, __ΩSerializedTypeBaseMember, __ΩSerializedTypeClassType, __ΩSerializedTypeEnum, __ΩSerializedTypeFunction, __ΩSerializedTypeIndexSignature, __ΩSerializedTypeInfer, __ΩSerializedTypeIntersection, __ΩSerializedTypeLiteral, __ΩSerializedTypeMethod, __ΩSerializedTypeMethodSignature, __ΩSerializedTypeObjectLiteral, __ΩSerializedTypeParameter, __ΩSerializedTypePromise, __ΩSerializedTypeProperty, __ΩSerializedTypePropertySignature, __ΩSerializedTypeReference, __ΩSerializedTypeRest, __ΩSerializedTypeTemplateLiteral, __ΩSerializedTypeTuple, __ΩSerializedTypeTupleMember, __ΩSerializedTypeTypeParameter, __ΩSerializedTypeUnion, __ΩSerializedTypes, __ΩSerializerFn, __ΩSerializerState, __ΩSignedBinaryBigInt, __ΩSimpleSerializedType, __ΩSqliteOptions, __ΩTagsReflection, __ΩTemplate, __ΩTemplateHook, __ΩTypeAny, __ΩTypeArray, __ΩTypeBaseMember, __ΩTypeBigInt, __ΩTypeBoolean, __ΩTypeCallSignature, __ΩTypeClass, __ΩTypeDecorator, __ΩTypeEnum, __ΩTypeEnumMember, __ΩTypeFunction, __ΩTypeIndexSignature, __ΩTypeInfer, __ΩTypeIntersection, __ΩTypeLiteral, __ΩTypeMethod, __ΩTypeMethodSignature, __ΩTypeNever, __ΩTypeNull, __ΩTypeNumber, __ΩTypeObject, __ΩTypeObjectLiteral, __ΩTypeParameter, __ΩTypePromise, __ΩTypeProperty, __ΩTypePropertySignature, __ΩTypeRegexp, __ΩTypeRest, __ΩTypeSettings, __ΩTypeString, __ΩTypeSymbol, __ΩTypeTemplateLiteral, __ΩTypeTuple, __ΩTypeTupleMember, __ΩTypeTypeParameter, __ΩTypeUndefined, __ΩTypeUnion, __ΩTypeUnknown, __ΩTypeVoid, __ΩTypedArray, __ΩTypedArrayClassType, __ΩUUID, __ΩUnionToIntersection, __ΩUnique, __ΩUnpopulatedCheck, __ΩValidate, __ΩValidateFunction, __ΩValidatorMeta, __ΩWiden, __ΩWithAnnotations, __Ωfloat, __Ωfloat32, __Ωfloat64, __Ωint16, __Ωint32, __Ωint8, __Ωinteger, __Ωuint16, __Ωuint32, __Ωuint8, _isExtendable, addType, annotateClass, applyScheduledAnnotations, arrayBufferFrom, arrayBufferTo, arrayBufferToBase64, assert, assertType, atomicChange, autoIncrementAnnotation, backReferenceAnnotation, base64ToArrayBuffer, base64ToTypedArray, binaryBigIntAnnotation, binaryTypes, buildChanges, buildFunction, callExtractedFunctionIfAvailable, cast, castFunction, changeSetSymbol, clearTypeJitContainer, cloneClass, collapsePath, copyAndSetParent, createClassDecoratorContext, createConverterJSForMember, createFluidDecorator, createFreeDecoratorContext, createPromiseObjectLiteral, createPropertyDecoratorContext, createReference, createReferenceClass, createSerializeFunction, createSnapshot, createTypeGuardFunction, dataAnnotation, databaseAnnotation, defaultAnnotation, defaultValue, deserialize2 as deserialize, deserializeEmbedded, deserializeFunction, deserializeType, embeddedAnnotation, emptyObject, encodeOps, entity, entityAnnotation, excludedAnnotation, executeTemplates, executeTypeArgumentAsArray, extendTemplateLiteral, extractStateToFunctionAndCallIt, findMember, flatten, flattenUnionTypes, forwardMapToArray, forwardSetToArray, genericEqual, getAlias, getAnnotationMeta, getAnnotations, getBackReferenceType, getChangeDetector, getClassType, getConstructorProperties, getConverterForSnapshot, getDeepConstructorProperties, getDomain, getEmbeddedProperty, getEnumType, getEnumValueIndexMatcher, getIndexCheck, getKeyType, getMapTypeToArray, getMember, getNTypeToArray, getNameExpression, getNominalId, getOrCreateReferenceItemInfo, getPartialSerializeFunction, getPartialType, getPatchSerializeFunction, getPermission, getPrimaryKeyExtractor, getPrimaryKeyHashGenerator, getProperty, getPropertyNameString, getReferenceInfo, getReferenceItemInfo, getReferenceType, getSerializeFunction, getSetTypeToArray, getSimplePrimaryKeyHashGenerator, getStaticDefaultCodeForProperty, getTags, getTitle, getTypeJitContainer, getTypeObjectLiteralFromTypeClass, getValidatorFunction, getValueType, groupAnnotation, guard, handleUnion, hasCircularReference, hasDefaultValue, hasEmbedded, hasMember, hasTypeInformation, inAccessor, indexAccess, indexAnnotation, is, isAutoIncrementType, isBackReferenceType, isBinary, isBinaryBigIntType, isCustomTypeClass, isDateType, isDecoratorContext, isExtendable, isGlobalTypeClass, isHidden, isIgnore, isIntegerType, isInternal, isMapType, isMember, isMongoIdType, isNullable, isOptional, isPrimaryKeyType, isPrimitive, isPropertyMemberType, isPropertyType, isReadonly, isReferenceHydrated, isReferenceInstance, isReferenceType, isSameType, isSetType, isType, isTypeClassOf, isTypeIncluded, isUUIDType, isWithAnnotations, isWithDeferredDecorators, mapNameAnnotation, markAsHydrated, memberNameToString, merge, mergeDecorator, typeAnnotation as metaAnnotation, mixin, mongoIdAnnotation, narrowOriginalLiteral, nodeBufferToArrayBuffer, nodeBufferToTypedArray, noopTemplate, pack, parametersToTuple, patch, pathResolver, primaryKeyAnnotation, propertiesOf, referenceAnnotation, referenceItemSymbol, referenceSymbol, reflect, reflectOrUndefined, reflectionClassSymbol, regExpFromString, registerTypeDecorator, removeNominal, removeTypeName, resolveClassType, resolveForeignReflectionClass, resolvePacked, resolvePath, resolveProperty, resolveReceiveType, resolveRuntimeType, resolveTypeMembers, serializableKinds, serialize2 as serialize, serializeArray, serializeFunction, serializeObjectLiteral, serializePropertyOrParameter, serializeType, serializer, snapshotSerializer, sortSignatures, stringifyResolvedType, stringifyShortResolvedType, stringifyType, stringifyUuid, t, toSignature, typeAnnotation, typeDecorators, typeGuardArray, typeGuardEmbedded, typeGuardObjectLiteral, typeInfer, typeOf, typeSettings, typeToObject, typedArrayToBase64, typedArrayToBuffer, unboxUnion, underscoreNamingStrategy, unpack, unpopulatedSymbol, uuid, uuidAnnotation, validate2 as validate, validateFunction, validatePropertyOrParameter, validatedDeserialize, validates, validationAnnotation, validators, valuesOf, visit, widenLiteral, writeUuid };