@gravito/core 2.0.4 → 2.0.6

package/dist/compat/async-local-storage.browser.js

@@ -0,0 +1,71 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/async-local-storage.browser.ts
+class AsyncLocalStorage {
+  store;
+  run(store, fn) {
+    const prev = this.store;
+    this.store = store;
+    try {
+      return fn();
+    } finally {
+      this.store = prev;
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+  disable() {
+    this.store = undefined;
+  }
+}
+export {
+  AsyncLocalStorage
+};
+
+//# debugId=1CD94D2F311BBD0564756E2164756E21

package/dist/compat/async-local-storage.browser.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/async-local-storage.browser.ts"],
+  "sourcesContent": [
+    "/**\n * Browser-safe AsyncLocalStorage mock\n */\nexport class AsyncLocalStorage<T> {\n  private store: T | undefined\n\n  run<R>(store: T, fn: () => R): R {\n    const prev = this.store\n    this.store = store\n    try {\n      return fn()\n    } finally {\n      this.store = prev\n    }\n  }\n\n  getStore(): T | undefined {\n    return this.store\n  }\n\n  disable(): void {\n    this.store = undefined\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,MAAM,kBAAqB;AAAA,EACxB;AAAA,EAER,GAAM,CAAC,OAAU,IAAgB;AAAA,IAC/B,MAAM,OAAO,KAAK;AAAA,IAClB,KAAK,QAAQ;AAAA,IACb,IAAI;AAAA,MACF,OAAO,GAAG;AAAA,cACV;AAAA,MACA,KAAK,QAAQ;AAAA;AAAA;AAAA,EAIjB,QAAQ,GAAkB;AAAA,IACxB,OAAO,KAAK;AAAA;AAAA,EAGd,OAAO,GAAS;AAAA,IACd,KAAK,QAAQ;AAAA;AAEjB;",
+  "debugId": "1CD94D2F311BBD0564756E2164756E21",
+  "names": []
+}

package/dist/compat/async-local-storage.js

@@ -0,0 +1,94 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/async-local-storage.ts
+var AsyncLocalStorageClass;
+var tryGetNodeAsyncHooks = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      try {
+        const module = __require("async_hooks");
+        return module.AsyncLocalStorage;
+      } catch (_e1) {
+        try {
+          return eval("require")("node:async_hooks").AsyncLocalStorage;
+        } catch (_e2) {
+          return null;
+        }
+      }
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+AsyncLocalStorageClass = tryGetNodeAsyncHooks();
+if (!AsyncLocalStorageClass) {
+  AsyncLocalStorageClass = class AsyncLocalStorage {
+    store;
+    run(store, fn) {
+      const prev = this.store;
+      this.store = store;
+      try {
+        return fn();
+      } finally {
+        this.store = prev;
+      }
+    }
+    getStore() {
+      return this.store;
+    }
+    disable() {
+      this.store = undefined;
+    }
+  };
+}
+var AsyncLocalStorage = AsyncLocalStorageClass;
+export {
+  AsyncLocalStorage
+};
+
+//# debugId=AEC51513D62BFF6864756E2164756E21

package/dist/compat/async-local-storage.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/async-local-storage.ts"],
+  "sourcesContent": [
+    "/**\n * Universal AsyncLocalStorage wrapper.\n * Automatically switches between node:async_hooks and a browser mock.\n */\n\nlet AsyncLocalStorageClass: any\n\n// Try to load Node.js AsyncLocalStorage\nconst tryGetNodeAsyncHooks = () => {\n  try {\n    if (\n      typeof window === 'undefined' &&\n      typeof process !== 'undefined' &&\n      !(process as any).browser\n    ) {\n      // Try direct import for Bun/Node.js ESM compatibility\n      try {\n        const module = require('node:async_hooks')\n        return module.AsyncLocalStorage\n      } catch (_e1) {\n        // Fallback to eval for CommonJS require hiding\n        try {\n          // biome-ignore lint/security/noGlobalEval: specialized case for hiding node built-ins\n          return eval('require')('node:async_hooks').AsyncLocalStorage\n        } catch (_e2) {\n          return null\n        }\n      }\n    }\n  } catch (_e) {\n    return null\n  }\n}\n\nAsyncLocalStorageClass = tryGetNodeAsyncHooks()\n\nif (!AsyncLocalStorageClass) {\n  /**\n   * Browser-safe AsyncLocalStorage mock.\n   * Note: This mock only works with synchronous functions.\n   * For proper async support, ensure Node.js AsyncLocalStorage is available.\n   */\n  AsyncLocalStorageClass = class AsyncLocalStorage<T> {\n    private store: T | undefined\n\n    run<R>(store: T, fn: () => R): R {\n      const prev = this.store\n      this.store = store\n      try {\n        return fn()\n      } finally {\n        this.store = prev\n      }\n    }\n\n    getStore(): T | undefined {\n      return this.store\n    }\n\n    disable(): void {\n      this.store = undefined\n    }\n  }\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: generic class mock\nexport const AsyncLocalStorage: { new <_T>(): any } = AsyncLocalStorageClass\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,IAAI;AAGJ,IAAM,uBAAuB,MAAM;AAAA,EACjC,IAAI;AAAA,IACF,IACE,OAAO,WAAW,eAClB,OAAO,YAAY,eACnB,MACA;AAAA,MAEA,IAAI;AAAA,QACF,MAAM;AAAA,QACN,OAAO,OAAO;AAAA,QACd,OAAO,KAAK;AAAA,QAEZ,IAAI;AAAA,UAEF,OAAO,KAAK,SAAS,EAAE,kBAAkB,EAAE;AAAA,UAC3C,OAAO,KAAK;AAAA,UACZ,OAAO;AAAA;AAAA;AAAA,IAGb;AAAA,IACA,OAAO,IAAI;AAAA,IACX,OAAO;AAAA;AAAA;AAIX,yBAAyB,qBAAqB;AAE9C,IAAI,CAAC,wBAAwB;AAAA,EAM3B,yBAAyB,MAAM,kBAAqB;AAAA,IAC1C;AAAA,IAER,GAAM,CAAC,OAAU,IAAgB;AAAA,MAC/B,MAAM,OAAO,KAAK;AAAA,MAClB,KAAK,QAAQ;AAAA,MACb,IAAI;AAAA,QACF,OAAO,GAAG;AAAA,gBACV;AAAA,QACA,KAAK,QAAQ;AAAA;AAAA;AAAA,IAIjB,QAAQ,GAAkB;AAAA,MACxB,OAAO,KAAK;AAAA;AAAA,IAGd,OAAO,GAAS;AAAA,MACd,KAAK,QAAQ;AAAA;AAAA,EAEjB;AACF;AAGO,IAAM,oBAAyC;",
+  "debugId": "AEC51513D62BFF6864756E2164756E21",
+  "names": []
+}

package/dist/compat/crypto.browser.js

@@ -0,0 +1,91 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/crypto.browser.ts
+var randomUUID = () => {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var randomBytes = (size) => {
+  const bytes = new Uint8Array(size);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0;i < size; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return {
+    length: size,
+    [Symbol.iterator]: () => bytes[Symbol.iterator](),
+    toString: (encoding) => {
+      if (encoding === "base64") {
+        let binary = "";
+        for (let i = 0;i < bytes.byteLength; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+      }
+      if (encoding === "hex") {
+        return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+      }
+      return "";
+    }
+  };
+};
+export {
+  randomUUID,
+  randomBytes
+};
+
+//# debugId=DA2B8600ADBAB27E64756E2164756E21

package/dist/compat/crypto.browser.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/crypto.browser.ts"],
+  "sourcesContent": [
+    "/**\n * Browser-safe crypto mock\n */\nexport const randomUUID = () => {\n  if (typeof globalThis.crypto?.randomUUID === 'function') {\n    return globalThis.crypto.randomUUID()\n  }\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = (Math.random() * 16) | 0\n    const v = c === 'x' ? r : (r & 0x3) | 0x8\n    return v.toString(16)\n  })\n}\n\nexport const randomBytes = (size: number) => {\n  const bytes = new Uint8Array(size)\n  if (typeof globalThis.crypto?.getRandomValues === 'function') {\n    globalThis.crypto.getRandomValues(bytes)\n  } else {\n    for (let i = 0; i < size; i++) {\n      bytes[i] = Math.floor(Math.random() * 256)\n    }\n  }\n\n  // Basic Buffer-like object for Str.ts compatibility\n  return {\n    length: size,\n    [Symbol.iterator]: () => bytes[Symbol.iterator](),\n    toString: (encoding: string) => {\n      if (encoding === 'base64') {\n        let binary = ''\n        for (let i = 0; i < bytes.byteLength; i++) {\n          binary += String.fromCharCode(bytes[i])\n        }\n        return btoa(binary)\n      }\n      if (encoding === 'hex') {\n        return Array.from(bytes)\n          .map((b) => b.toString(16).padStart(2, '0'))\n          .join('')\n      }\n      return ''\n    },\n  } as unknown as Buffer\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,IAAM,aAAa,MAAM;AAAA,EAC9B,IAAI,OAAO,WAAW,QAAQ,eAAe,YAAY;AAAA,IACvD,OAAO,WAAW,OAAO,WAAW;AAAA,EACtC;AAAA,EACA,OAAO,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAAA,IACpE,MAAM,IAAK,KAAK,OAAO,IAAI,KAAM;AAAA,IACjC,MAAM,IAAI,MAAM,MAAM,IAAK,IAAI,IAAO;AAAA,IACtC,OAAO,EAAE,SAAS,EAAE;AAAA,GACrB;AAAA;AAGI,IAAM,cAAc,CAAC,SAAiB;AAAA,EAC3C,MAAM,QAAQ,IAAI,WAAW,IAAI;AAAA,EACjC,IAAI,OAAO,WAAW,QAAQ,oBAAoB,YAAY;AAAA,IAC5D,WAAW,OAAO,gBAAgB,KAAK;AAAA,EACzC,EAAO;AAAA,IACL,SAAS,IAAI,EAAG,IAAI,MAAM,KAAK;AAAA,MAC7B,MAAM,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;AAAA,IAC3C;AAAA;AAAA,EAIF,OAAO;AAAA,IACL,QAAQ;AAAA,KACP,OAAO,WAAW,MAAM,MAAM,OAAO,UAAU;AAAA,IAChD,UAAU,CAAC,aAAqB;AAAA,MAC9B,IAAI,aAAa,UAAU;AAAA,QACzB,IAAI,SAAS;AAAA,QACb,SAAS,IAAI,EAAG,IAAI,MAAM,YAAY,KAAK;AAAA,UACzC,UAAU,OAAO,aAAa,MAAM,EAAE;AAAA,QACxC;AAAA,QACA,OAAO,KAAK,MAAM;AAAA,MACpB;AAAA,MACA,IAAI,aAAa,OAAO;AAAA,QACtB,OAAO,MAAM,KAAK,KAAK,EACpB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AAAA,MACZ;AAAA,MACA,OAAO;AAAA;AAAA,EAEX;AAAA;",
+  "debugId": "DA2B8600ADBAB27E64756E2164756E21",
+  "names": []
+}

package/dist/compat/crypto.js

@@ -0,0 +1,111 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/crypto.ts
+var randomUUIDFn;
+var randomBytesFn;
+var tryGetNodeCrypto = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      return eval("require")("node:crypto");
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+var nodeCrypto = tryGetNodeCrypto();
+if (nodeCrypto) {
+  randomUUIDFn = nodeCrypto.randomUUID;
+  randomBytesFn = nodeCrypto.randomBytes;
+} else {
+  randomUUIDFn = () => {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  };
+  randomBytesFn = (size) => {
+    const bytes = new Uint8Array(size);
+    if (typeof globalThis.crypto?.getRandomValues === "function") {
+      globalThis.crypto.getRandomValues(bytes);
+    } else {
+      for (let i = 0;i < size; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return {
+      ...Array.from(bytes),
+      length: size,
+      [Symbol.iterator]: () => bytes[Symbol.iterator](),
+      toString: (encoding) => {
+        if (encoding === "base64") {
+          let binary = "";
+          for (let i = 0;i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        if (encoding === "hex") {
+          return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        return "";
+      }
+    };
+  };
+}
+var randomUUID = randomUUIDFn;
+var randomBytes = randomBytesFn;
+export {
+  randomUUID,
+  randomBytes
+};
+
+//# debugId=90A5E907AAB9EDB264756E2164756E21

package/dist/compat/crypto.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/crypto.ts"],
+  "sourcesContent": [
+    "/**\n * Universal Crypto wrapper.\n * Automatically switches between node:crypto and globalThis.crypto.\n */\n\nlet randomUUIDFn: () => string\nlet randomBytesFn: (size: number) => any\n\nconst tryGetNodeCrypto = () => {\n  try {\n    if (\n      typeof window === 'undefined' &&\n      typeof process !== 'undefined' &&\n      !(process as any).browser\n    ) {\n      // biome-ignore lint/security/noGlobalEval: specialized case for hiding node built-ins\n      return eval('require')('node:crypto')\n    }\n  } catch (_e) {\n    return null\n  }\n}\n\nconst nodeCrypto = tryGetNodeCrypto()\n\nif (nodeCrypto) {\n  randomUUIDFn = nodeCrypto.randomUUID\n  randomBytesFn = nodeCrypto.randomBytes\n} else {\n  // Browser implementations\n  randomUUIDFn = () => {\n    if (typeof globalThis.crypto?.randomUUID === 'function') {\n      return globalThis.crypto.randomUUID()\n    }\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n      const r = (Math.random() * 16) | 0\n      const v = c === 'x' ? r : (r & 0x3) | 0x8\n      return v.toString(16)\n    })\n  }\n\n  randomBytesFn = (size: number) => {\n    const bytes = new Uint8Array(size)\n    if (typeof globalThis.crypto?.getRandomValues === 'function') {\n      globalThis.crypto.getRandomValues(bytes)\n    } else {\n      for (let i = 0; i < size; i++) {\n        bytes[i] = Math.floor(Math.random() * 256)\n      }\n    }\n    // Return a Buffer-like object\n    return {\n      ...Array.from(bytes),\n      length: size,\n      [Symbol.iterator]: () => bytes[Symbol.iterator](),\n      toString: (encoding: string) => {\n        if (encoding === 'base64') {\n          let binary = ''\n          for (let i = 0; i < bytes.byteLength; i++) {\n            binary += String.fromCharCode(bytes[i])\n          }\n          return btoa(binary)\n        }\n        if (encoding === 'hex') {\n          return Array.from(bytes)\n            .map((b) => b.toString(16).padStart(2, '0'))\n            .join('')\n        }\n        return ''\n      },\n    }\n  }\n}\n\nexport const randomUUID = randomUUIDFn\nexport const randomBytes = randomBytesFn\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,IAAI;AACJ,IAAI;AAEJ,IAAM,mBAAmB,MAAM;AAAA,EAC7B,IAAI;AAAA,IACF,IACE,OAAO,WAAW,eAClB,OAAO,YAAY,eACnB,MACA;AAAA,MAEA,OAAO,KAAK,SAAS,EAAE,aAAa;AAAA,IACtC;AAAA,IACA,OAAO,IAAI;AAAA,IACX,OAAO;AAAA;AAAA;AAIX,IAAM,aAAa,iBAAiB;AAEpC,IAAI,YAAY;AAAA,EACd,eAAe,WAAW;AAAA,EAC1B,gBAAgB,WAAW;AAC7B,EAAO;AAAA,EAEL,eAAe,MAAM;AAAA,IACnB,IAAI,OAAO,WAAW,QAAQ,eAAe,YAAY;AAAA,MACvD,OAAO,WAAW,OAAO,WAAW;AAAA,IACtC;AAAA,IACA,OAAO,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAAA,MACpE,MAAM,IAAK,KAAK,OAAO,IAAI,KAAM;AAAA,MACjC,MAAM,IAAI,MAAM,MAAM,IAAK,IAAI,IAAO;AAAA,MACtC,OAAO,EAAE,SAAS,EAAE;AAAA,KACrB;AAAA;AAAA,EAGH,gBAAgB,CAAC,SAAiB;AAAA,IAChC,MAAM,QAAQ,IAAI,WAAW,IAAI;AAAA,IACjC,IAAI,OAAO,WAAW,QAAQ,oBAAoB,YAAY;AAAA,MAC5D,WAAW,OAAO,gBAAgB,KAAK;AAAA,IACzC,EAAO;AAAA,MACL,SAAS,IAAI,EAAG,IAAI,MAAM,KAAK;AAAA,QAC7B,MAAM,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;AAAA,MAC3C;AAAA;AAAA,IAGF,OAAO;AAAA,SACF,MAAM,KAAK,KAAK;AAAA,MACnB,QAAQ;AAAA,OACP,OAAO,WAAW,MAAM,MAAM,OAAO,UAAU;AAAA,MAChD,UAAU,CAAC,aAAqB;AAAA,QAC9B,IAAI,aAAa,UAAU;AAAA,UACzB,IAAI,SAAS;AAAA,UACb,SAAS,IAAI,EAAG,IAAI,MAAM,YAAY,KAAK;AAAA,YACzC,UAAU,OAAO,aAAa,MAAM,EAAE;AAAA,UACxC;AAAA,UACA,OAAO,KAAK,MAAM;AAAA,QACpB;AAAA,QACA,IAAI,aAAa,OAAO;AAAA,UACtB,OAAO,MAAM,KAAK,KAAK,EACpB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AAAA,QACZ;AAAA,QACA,OAAO;AAAA;AAAA,IAEX;AAAA;AAAA;AAIG,IAAM,aAAa;AACnB,IAAM,cAAc;",
+  "debugId": "90A5E907AAB9EDB264756E2164756E21",
+  "names": []
+}