@automerge/automerge-repo-react-hooks 2.5.0-alpha.2 → 2.5.1

package/dist/index.js

@@ -1,1242 +1,2150 @@
-import ke, { createContext as Oe, useContext as Fe, useRef as qe, useState as X, useEffect as z, useCallback as Le } from "react";
-function Ue(e) {
-  let t = "pending", n, H;
-  const y = e.then(
-    (w) => {
-      t = "success", n = w;
+import require$$0, { createContext, useContext, useRef, useState, useEffect, useCallback } from 'react';
+
+function wrapPromise(promise) {
+  let status = "pending";
+  let result;
+  let error;
+  const suspender = promise.then(
+    (data) => {
+      status = "success";
+      result = data;
     },
-    (w) => {
-      t = "error", H = w;
+    (err) => {
+      status = "error";
+      error = err;
     }
   );
   return {
-    promise: e,
+    promise,
     read() {
-      switch (t) {
+      switch (status) {
         case "pending":
-          throw y;
+          throw suspender;
         case "error":
-          throw H;
+          throw error;
         case "success":
-          return n;
+          return result;
       }
     }
   };
 }
-const Ge = Oe(null);
-function Ve() {
-  const e = Fe(Ge);
-  if (!e) throw new Error("Repo was not found on RepoContext.");
-  return e;
+
+const RepoContext = createContext(null);
+function useRepo() {
+  const repo = useContext(RepoContext);
+  if (!repo) throw new Error("Repo was not found on RepoContext.");
+  return repo;
 }
-const Pe = /^(?:[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;
-function de(e) {
-  return typeof e == "string" && Pe.test(e);
+
+const REGEX = /^(?:[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;
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
 }
-function je(e) {
-  if (!de(e))
-    throw TypeError("Invalid UUID");
-  let t;
-  const n = new Uint8Array(16);
-  return n[0] = (t = parseInt(e.slice(0, 8), 16)) >>> 24, n[1] = t >>> 16 & 255, n[2] = t >>> 8 & 255, n[3] = t & 255, n[4] = (t = parseInt(e.slice(9, 13), 16)) >>> 8, n[5] = t & 255, n[6] = (t = parseInt(e.slice(14, 18), 16)) >>> 8, n[7] = t & 255, n[8] = (t = parseInt(e.slice(19, 23), 16)) >>> 8, n[9] = t & 255, n[10] = (t = parseInt(e.slice(24, 36), 16)) / 1099511627776 & 255, n[11] = t / 4294967296 & 255, n[12] = t >>> 24 & 255, n[13] = t >>> 16 & 255, n[14] = t >>> 8 & 255, n[15] = t & 255, n;
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  let v;
+  const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
 }
-function be(e) {
-  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
-var $ = {}, T = {}, P = {}, se = {}, J = {}, pe;
-function We() {
-  return pe || (pe = 1, Object.defineProperty(J, "__esModule", { value: !0 }), J.crypto = void 0, J.crypto = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0), J;
+
+var sha256 = {};
+
+var sha2 = {};
+
+var _md = {};
+
+var utils = {};
+
+var crypto = {};
+
+var hasRequiredCrypto;
+
+function requireCrypto () {
+	if (hasRequiredCrypto) return crypto;
+	hasRequiredCrypto = 1;
+	Object.defineProperty(crypto, "__esModule", { value: true });
+	crypto.crypto = void 0;
+	crypto.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+	
+	return crypto;
 }
-var He;
-function Ce() {
-  return He || (He = 1, function(e) {
-    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-    Object.defineProperty(e, "__esModule", { value: !0 }), e.wrapXOFConstructorWithOpts = e.wrapConstructorWithOpts = e.wrapConstructor = e.Hash = e.nextTick = e.swap32IfBE = e.byteSwapIfBE = e.swap8IfBE = e.isLE = void 0, e.isBytes = n, e.anumber = H, e.abytes = y, e.ahash = w, e.aexists = a, e.aoutput = c, e.u8 = s, e.u32 = o, e.clean = i, e.createView = h, e.rotr = m, e.rotl = B, e.byteSwap = f, e.byteSwap32 = g, e.bytesToHex = M, e.hexToBytes = A, e.asyncLoop = L, e.utf8ToBytes = E, e.bytesToUtf8 = u, e.toBytes = l, e.kdfInputToBytes = b, e.concatBytes = C, e.checkOpts = S, e.createHasher = O, e.createOptHasher = F, e.createXOFer = q, e.randomBytes = j;
-    const t = /* @__PURE__ */ We();
-    function n(r) {
-      return r instanceof Uint8Array || ArrayBuffer.isView(r) && r.constructor.name === "Uint8Array";
-    }
-    function H(r) {
-      if (!Number.isSafeInteger(r) || r < 0)
-        throw new Error("positive integer expected, got " + r);
-    }
-    function y(r, ...p) {
-      if (!n(r))
-        throw new Error("Uint8Array expected");
-      if (p.length > 0 && !p.includes(r.length))
-        throw new Error("Uint8Array expected of length " + p + ", got length=" + r.length);
-    }
-    function w(r) {
-      if (typeof r != "function" || typeof r.create != "function")
-        throw new Error("Hash should be wrapped by utils.createHasher");
-      H(r.outputLen), H(r.blockLen);
-    }
-    function a(r, p = !0) {
-      if (r.destroyed)
-        throw new Error("Hash instance has been destroyed");
-      if (p && r.finished)
-        throw new Error("Hash#digest() has already been called");
-    }
-    function c(r, p) {
-      y(r);
-      const v = p.outputLen;
-      if (r.length < v)
-        throw new Error("digestInto() expects output buffer of length at least " + v);
-    }
-    function s(r) {
-      return new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
-    }
-    function o(r) {
-      return new Uint32Array(r.buffer, r.byteOffset, Math.floor(r.byteLength / 4));
-    }
-    function i(...r) {
-      for (let p = 0; p < r.length; p++)
-        r[p].fill(0);
-    }
-    function h(r) {
-      return new DataView(r.buffer, r.byteOffset, r.byteLength);
-    }
-    function m(r, p) {
-      return r << 32 - p | r >>> p;
-    }
-    function B(r, p) {
-      return r << p | r >>> 32 - p >>> 0;
-    }
-    e.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-    function f(r) {
-      return r << 24 & 4278190080 | r << 8 & 16711680 | r >>> 8 & 65280 | r >>> 24 & 255;
-    }
-    e.swap8IfBE = e.isLE ? (r) => r : (r) => f(r), e.byteSwapIfBE = e.swap8IfBE;
-    function g(r) {
-      for (let p = 0; p < r.length; p++)
-        r[p] = f(r[p]);
-      return r;
-    }
-    e.swap32IfBE = e.isLE ? (r) => r : g;
-    const d = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", V = /* @__PURE__ */ Array.from({ length: 256 }, (r, p) => p.toString(16).padStart(2, "0"));
-    function M(r) {
-      if (y(r), d)
-        return r.toHex();
-      let p = "";
-      for (let v = 0; v < r.length; v++)
-        p += V[r[v]];
-      return p;
-    }
-    const x = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-    function R(r) {
-      if (r >= x._0 && r <= x._9)
-        return r - x._0;
-      if (r >= x.A && r <= x.F)
-        return r - (x.A - 10);
-      if (r >= x.a && r <= x.f)
-        return r - (x.a - 10);
-    }
-    function A(r) {
-      if (typeof r != "string")
-        throw new Error("hex string expected, got " + typeof r);
-      if (d)
-        return Uint8Array.fromHex(r);
-      const p = r.length, v = p / 2;
-      if (p % 2)
-        throw new Error("hex string expected, got unpadded hex of length " + p);
-      const D = new Uint8Array(v);
-      for (let k = 0, G = 0; k < v; k++, G += 2) {
-        const K = R(r.charCodeAt(G)), W = R(r.charCodeAt(G + 1));
-        if (K === void 0 || W === void 0) {
-          const N = r[G] + r[G + 1];
-          throw new Error('hex string expected, got non-hex character "' + N + '" at index ' + G);
-        }
-        D[k] = K * 16 + W;
-      }
-      return D;
-    }
-    const I = async () => {
-    };
-    e.nextTick = I;
-    async function L(r, p, v) {
-      let D = Date.now();
-      for (let k = 0; k < r; k++) {
-        v(k);
-        const G = Date.now() - D;
-        G >= 0 && G < p || (await (0, e.nextTick)(), D += G);
-      }
-    }
-    function E(r) {
-      if (typeof r != "string")
-        throw new Error("string expected");
-      return new Uint8Array(new TextEncoder().encode(r));
-    }
-    function u(r) {
-      return new TextDecoder().decode(r);
-    }
-    function l(r) {
-      return typeof r == "string" && (r = E(r)), y(r), r;
-    }
-    function b(r) {
-      return typeof r == "string" && (r = E(r)), y(r), r;
-    }
-    function C(...r) {
-      let p = 0;
-      for (let D = 0; D < r.length; D++) {
-        const k = r[D];
-        y(k), p += k.length;
-      }
-      const v = new Uint8Array(p);
-      for (let D = 0, k = 0; D < r.length; D++) {
-        const G = r[D];
-        v.set(G, k), k += G.length;
-      }
-      return v;
-    }
-    function S(r, p) {
-      if (p !== void 0 && {}.toString.call(p) !== "[object Object]")
-        throw new Error("options should be object or undefined");
-      return Object.assign(r, p);
-    }
-    class U {
-    }
-    e.Hash = U;
-    function O(r) {
-      const p = (D) => r().update(l(D)).digest(), v = r();
-      return p.outputLen = v.outputLen, p.blockLen = v.blockLen, p.create = () => r(), p;
-    }
-    function F(r) {
-      const p = (D, k) => r(k).update(l(D)).digest(), v = r({});
-      return p.outputLen = v.outputLen, p.blockLen = v.blockLen, p.create = (D) => r(D), p;
-    }
-    function q(r) {
-      const p = (D, k) => r(k).update(l(D)).digest(), v = r({});
-      return p.outputLen = v.outputLen, p.blockLen = v.blockLen, p.create = (D) => r(D), p;
-    }
-    e.wrapConstructor = O, e.wrapConstructorWithOpts = F, e.wrapXOFConstructorWithOpts = q;
-    function j(r = 32) {
-      if (t.crypto && typeof t.crypto.getRandomValues == "function")
-        return t.crypto.getRandomValues(new Uint8Array(r));
-      if (t.crypto && typeof t.crypto.randomBytes == "function")
-        return Uint8Array.from(t.crypto.randomBytes(r));
-      throw new Error("crypto.getRandomValues must be defined");
-    }
-  }(se)), se;
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		/**
+		 * Utilities for hex, bytes, CSPRNG.
+		 * @module
+		 */
+		/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+		exports.isBytes = isBytes;
+		exports.anumber = anumber;
+		exports.abytes = abytes;
+		exports.ahash = ahash;
+		exports.aexists = aexists;
+		exports.aoutput = aoutput;
+		exports.u8 = u8;
+		exports.u32 = u32;
+		exports.clean = clean;
+		exports.createView = createView;
+		exports.rotr = rotr;
+		exports.rotl = rotl;
+		exports.byteSwap = byteSwap;
+		exports.byteSwap32 = byteSwap32;
+		exports.bytesToHex = bytesToHex;
+		exports.hexToBytes = hexToBytes;
+		exports.asyncLoop = asyncLoop;
+		exports.utf8ToBytes = utf8ToBytes;
+		exports.bytesToUtf8 = bytesToUtf8;
+		exports.toBytes = toBytes;
+		exports.kdfInputToBytes = kdfInputToBytes;
+		exports.concatBytes = concatBytes;
+		exports.checkOpts = checkOpts;
+		exports.createHasher = createHasher;
+		exports.createOptHasher = createOptHasher;
+		exports.createXOFer = createXOFer;
+		exports.randomBytes = randomBytes;
+		// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+		// node.js versions earlier than v19 don't declare it in global scope.
+		// For node.js, package.json#exports field mapping rewrites import
+		// from `crypto` to `cryptoNode`, which imports native module.
+		// Makes the utils un-importable in browsers without a bundler.
+		// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+		const crypto_1 = /*@__PURE__*/ requireCrypto();
+		/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+		function isBytes(a) {
+		    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+		}
+		/** Asserts something is positive integer. */
+		function anumber(n) {
+		    if (!Number.isSafeInteger(n) || n < 0)
+		        throw new Error('positive integer expected, got ' + n);
+		}
+		/** Asserts something is Uint8Array. */
+		function abytes(b, ...lengths) {
+		    if (!isBytes(b))
+		        throw new Error('Uint8Array expected');
+		    if (lengths.length > 0 && !lengths.includes(b.length))
+		        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+		}
+		/** Asserts something is hash */
+		function ahash(h) {
+		    if (typeof h !== 'function' || typeof h.create !== 'function')
+		        throw new Error('Hash should be wrapped by utils.createHasher');
+		    anumber(h.outputLen);
+		    anumber(h.blockLen);
+		}
+		/** Asserts a hash instance has not been destroyed / finished */
+		function aexists(instance, checkFinished = true) {
+		    if (instance.destroyed)
+		        throw new Error('Hash instance has been destroyed');
+		    if (checkFinished && instance.finished)
+		        throw new Error('Hash#digest() has already been called');
+		}
+		/** Asserts output is properly-sized byte array */
+		function aoutput(out, instance) {
+		    abytes(out);
+		    const min = instance.outputLen;
+		    if (out.length < min) {
+		        throw new Error('digestInto() expects output buffer of length at least ' + min);
+		    }
+		}
+		/** Cast u8 / u16 / u32 to u8. */
+		function u8(arr) {
+		    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+		}
+		/** Cast u8 / u16 / u32 to u32. */
+		function u32(arr) {
+		    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+		}
+		/** Zeroize a byte array. Warning: JS provides no guarantees. */
+		function clean(...arrays) {
+		    for (let i = 0; i < arrays.length; i++) {
+		        arrays[i].fill(0);
+		    }
+		}
+		/** Create DataView of an array for easy byte-level manipulation. */
+		function createView(arr) {
+		    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+		}
+		/** The rotate right (circular right shift) operation for uint32 */
+		function rotr(word, shift) {
+		    return (word << (32 - shift)) | (word >>> shift);
+		}
+		/** The rotate left (circular left shift) operation for uint32 */
+		function rotl(word, shift) {
+		    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+		}
+		/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+		exports.isLE = (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+		/** The byte swap operation for uint32 */
+		function byteSwap(word) {
+		    return (((word << 24) & 0xff000000) |
+		        ((word << 8) & 0xff0000) |
+		        ((word >>> 8) & 0xff00) |
+		        ((word >>> 24) & 0xff));
+		}
+		/** Conditionally byte swap if on a big-endian platform */
+		exports.swap8IfBE = exports.isLE
+		    ? (n) => n
+		    : (n) => byteSwap(n);
+		/** @deprecated */
+		exports.byteSwapIfBE = exports.swap8IfBE;
+		/** In place byte swap for Uint32Array */
+		function byteSwap32(arr) {
+		    for (let i = 0; i < arr.length; i++) {
+		        arr[i] = byteSwap(arr[i]);
+		    }
+		    return arr;
+		}
+		exports.swap32IfBE = exports.isLE
+		    ? (u) => u
+		    : byteSwap32;
+		// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+		const hasHexBuiltin = /* @__PURE__ */ (() => 
+		// @ts-ignore
+		typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+		// Array where index 0xf0 (240) is mapped to string 'f0'
+		const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+		/**
+		 * Convert byte array to hex string. Uses built-in function, when available.
+		 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+		 */
+		function bytesToHex(bytes) {
+		    abytes(bytes);
+		    // @ts-ignore
+		    if (hasHexBuiltin)
+		        return bytes.toHex();
+		    // pre-caching improves the speed 6x
+		    let hex = '';
+		    for (let i = 0; i < bytes.length; i++) {
+		        hex += hexes[bytes[i]];
+		    }
+		    return hex;
+		}
+		// We use optimized technique to convert hex string to byte array
+		const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+		function asciiToBase16(ch) {
+		    if (ch >= asciis._0 && ch <= asciis._9)
+		        return ch - asciis._0; // '2' => 50-48
+		    if (ch >= asciis.A && ch <= asciis.F)
+		        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+		    if (ch >= asciis.a && ch <= asciis.f)
+		        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+		    return;
+		}
+		/**
+		 * Convert hex string to byte array. Uses built-in function, when available.
+		 * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+		 */
+		function hexToBytes(hex) {
+		    if (typeof hex !== 'string')
+		        throw new Error('hex string expected, got ' + typeof hex);
+		    // @ts-ignore
+		    if (hasHexBuiltin)
+		        return Uint8Array.fromHex(hex);
+		    const hl = hex.length;
+		    const al = hl / 2;
+		    if (hl % 2)
+		        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+		    const array = new Uint8Array(al);
+		    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+		        const n1 = asciiToBase16(hex.charCodeAt(hi));
+		        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+		        if (n1 === undefined || n2 === undefined) {
+		            const char = hex[hi] + hex[hi + 1];
+		            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+		        }
+		        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+		    }
+		    return array;
+		}
+		/**
+		 * There is no setImmediate in browser and setTimeout is slow.
+		 * Call of async fn will return Promise, which will be fullfiled only on
+		 * next scheduler queue processing step and this is exactly what we need.
+		 */
+		const nextTick = async () => { };
+		exports.nextTick = nextTick;
+		/** Returns control to thread each 'tick' ms to avoid blocking. */
+		async function asyncLoop(iters, tick, cb) {
+		    let ts = Date.now();
+		    for (let i = 0; i < iters; i++) {
+		        cb(i);
+		        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+		        const diff = Date.now() - ts;
+		        if (diff >= 0 && diff < tick)
+		            continue;
+		        await (0, exports.nextTick)();
+		        ts += diff;
+		    }
+		}
+		/**
+		 * Converts string to bytes using UTF8 encoding.
+		 * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+		 */
+		function utf8ToBytes(str) {
+		    if (typeof str !== 'string')
+		        throw new Error('string expected');
+		    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+		}
+		/**
+		 * Converts bytes to string using UTF8 encoding.
+		 * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
+		 */
+		function bytesToUtf8(bytes) {
+		    return new TextDecoder().decode(bytes);
+		}
+		/**
+		 * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+		 * Warning: when Uint8Array is passed, it would NOT get copied.
+		 * Keep in mind for future mutable operations.
+		 */
+		function toBytes(data) {
+		    if (typeof data === 'string')
+		        data = utf8ToBytes(data);
+		    abytes(data);
+		    return data;
+		}
+		/**
+		 * Helper for KDFs: consumes uint8array or string.
+		 * When string is passed, does utf8 decoding, using TextDecoder.
+		 */
+		function kdfInputToBytes(data) {
+		    if (typeof data === 'string')
+		        data = utf8ToBytes(data);
+		    abytes(data);
+		    return data;
+		}
+		/** Copies several Uint8Arrays into one. */
+		function concatBytes(...arrays) {
+		    let sum = 0;
+		    for (let i = 0; i < arrays.length; i++) {
+		        const a = arrays[i];
+		        abytes(a);
+		        sum += a.length;
+		    }
+		    const res = new Uint8Array(sum);
+		    for (let i = 0, pad = 0; i < arrays.length; i++) {
+		        const a = arrays[i];
+		        res.set(a, pad);
+		        pad += a.length;
+		    }
+		    return res;
+		}
+		function checkOpts(defaults, opts) {
+		    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+		        throw new Error('options should be object or undefined');
+		    const merged = Object.assign(defaults, opts);
+		    return merged;
+		}
+		/** For runtime check if class implements interface */
+		class Hash {
+		}
+		exports.Hash = Hash;
+		/** Wraps hash function, creating an interface on top of it */
+		function createHasher(hashCons) {
+		    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+		    const tmp = hashCons();
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = () => hashCons();
+		    return hashC;
+		}
+		function createOptHasher(hashCons) {
+		    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		    const tmp = hashCons({});
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = (opts) => hashCons(opts);
+		    return hashC;
+		}
+		function createXOFer(hashCons) {
+		    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		    const tmp = hashCons({});
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = (opts) => hashCons(opts);
+		    return hashC;
+		}
+		exports.wrapConstructor = createHasher;
+		exports.wrapConstructorWithOpts = createOptHasher;
+		exports.wrapXOFConstructorWithOpts = createXOFer;
+		/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+		function randomBytes(bytesLength = 32) {
+		    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+		        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+		    }
+		    // Legacy Node.js compatibility
+		    if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === 'function') {
+		        return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+		    }
+		    throw new Error('crypto.getRandomValues must be defined');
+		}
+		
+	} (utils));
+	return utils;
 }
-var ye;
-function Ne() {
-  if (ye) return P;
-  ye = 1, Object.defineProperty(P, "__esModule", { value: !0 }), P.SHA512_IV = P.SHA384_IV = P.SHA224_IV = P.SHA256_IV = P.HashMD = void 0, P.setBigUint64 = t, P.Chi = n, P.Maj = H;
-  const e = /* @__PURE__ */ Ce();
-  function t(w, a, c, s) {
-    if (typeof w.setBigUint64 == "function")
-      return w.setBigUint64(a, c, s);
-    const o = BigInt(32), i = BigInt(4294967295), h = Number(c >> o & i), m = Number(c & i), B = s ? 4 : 0, f = s ? 0 : 4;
-    w.setUint32(a + B, h, s), w.setUint32(a + f, m, s);
-  }
-  function n(w, a, c) {
-    return w & a ^ ~w & c;
-  }
-  function H(w, a, c) {
-    return w & a ^ w & c ^ a & c;
-  }
-  class y extends e.Hash {
-    constructor(a, c, s, o) {
-      super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = a, this.outputLen = c, this.padOffset = s, this.isLE = o, this.buffer = new Uint8Array(a), this.view = (0, e.createView)(this.buffer);
-    }
-    update(a) {
-      (0, e.aexists)(this), a = (0, e.toBytes)(a), (0, e.abytes)(a);
-      const { view: c, buffer: s, blockLen: o } = this, i = a.length;
-      for (let h = 0; h < i; ) {
-        const m = Math.min(o - this.pos, i - h);
-        if (m === o) {
-          const B = (0, e.createView)(a);
-          for (; o <= i - h; h += o)
-            this.process(B, h);
-          continue;
-        }
-        s.set(a.subarray(h, h + m), this.pos), this.pos += m, h += m, this.pos === o && (this.process(c, 0), this.pos = 0);
-      }
-      return this.length += a.length, this.roundClean(), this;
-    }
-    digestInto(a) {
-      (0, e.aexists)(this), (0, e.aoutput)(a, this), this.finished = !0;
-      const { buffer: c, view: s, blockLen: o, isLE: i } = this;
-      let { pos: h } = this;
-      c[h++] = 128, (0, e.clean)(this.buffer.subarray(h)), this.padOffset > o - h && (this.process(s, 0), h = 0);
-      for (let d = h; d < o; d++)
-        c[d] = 0;
-      t(s, o - 8, BigInt(this.length * 8), i), this.process(s, 0);
-      const m = (0, e.createView)(a), B = this.outputLen;
-      if (B % 4)
-        throw new Error("_sha2: outputLen should be aligned to 32bit");
-      const f = B / 4, g = this.get();
-      if (f > g.length)
-        throw new Error("_sha2: outputLen bigger than state");
-      for (let d = 0; d < f; d++)
-        m.setUint32(4 * d, g[d], i);
-    }
-    digest() {
-      const { buffer: a, outputLen: c } = this;
-      this.digestInto(a);
-      const s = a.slice(0, c);
-      return this.destroy(), s;
-    }
-    _cloneInto(a) {
-      a || (a = new this.constructor()), a.set(...this.get());
-      const { blockLen: c, buffer: s, length: o, finished: i, destroyed: h, pos: m } = this;
-      return a.destroyed = h, a.finished = i, a.length = o, a.pos = m, o % c && a.buffer.set(s), a;
-    }
-    clone() {
-      return this._cloneInto();
-    }
-  }
-  return P.HashMD = y, P.SHA256_IV = Uint32Array.from([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]), P.SHA224_IV = Uint32Array.from([
-    3238371032,
-    914150663,
-    812702999,
-    4144912697,
-    4290775857,
-    1750603025,
-    1694076839,
-    3204075428
-  ]), P.SHA384_IV = Uint32Array.from([
-    3418070365,
-    3238371032,
-    1654270250,
-    914150663,
-    2438529370,
-    812702999,
-    355462360,
-    4144912697,
-    1731405415,
-    4290775857,
-    2394180231,
-    1750603025,
-    3675008525,
-    1694076839,
-    1203062813,
-    3204075428
-  ]), P.SHA512_IV = Uint32Array.from([
-    1779033703,
-    4089235720,
-    3144134277,
-    2227873595,
-    1013904242,
-    4271175723,
-    2773480762,
-    1595750129,
-    1359893119,
-    2917565137,
-    2600822924,
-    725511199,
-    528734635,
-    4215389547,
-    1541459225,
-    327033209
-  ]), P;
+
+var hasRequired_md;
+
+function require_md () {
+	if (hasRequired_md) return _md;
+	hasRequired_md = 1;
+	Object.defineProperty(_md, "__esModule", { value: true });
+	_md.SHA512_IV = _md.SHA384_IV = _md.SHA224_IV = _md.SHA256_IV = _md.HashMD = void 0;
+	_md.setBigUint64 = setBigUint64;
+	_md.Chi = Chi;
+	_md.Maj = Maj;
+	/**
+	 * Internal Merkle-Damgard hash utils.
+	 * @module
+	 */
+	const utils_ts_1 = /*@__PURE__*/ requireUtils();
+	/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+	function setBigUint64(view, byteOffset, value, isLE) {
+	    if (typeof view.setBigUint64 === 'function')
+	        return view.setBigUint64(byteOffset, value, isLE);
+	    const _32n = BigInt(32);
+	    const _u32_max = BigInt(0xffffffff);
+	    const wh = Number((value >> _32n) & _u32_max);
+	    const wl = Number(value & _u32_max);
+	    const h = isLE ? 4 : 0;
+	    const l = isLE ? 0 : 4;
+	    view.setUint32(byteOffset + h, wh, isLE);
+	    view.setUint32(byteOffset + l, wl, isLE);
+	}
+	/** Choice: a ? b : c */
+	function Chi(a, b, c) {
+	    return (a & b) ^ (~a & c);
+	}
+	/** Majority function, true if any two inputs is true. */
+	function Maj(a, b, c) {
+	    return (a & b) ^ (a & c) ^ (b & c);
+	}
+	/**
+	 * Merkle-Damgard hash construction base class.
+	 * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+	 */
+	class HashMD extends utils_ts_1.Hash {
+	    constructor(blockLen, outputLen, padOffset, isLE) {
+	        super();
+	        this.finished = false;
+	        this.length = 0;
+	        this.pos = 0;
+	        this.destroyed = false;
+	        this.blockLen = blockLen;
+	        this.outputLen = outputLen;
+	        this.padOffset = padOffset;
+	        this.isLE = isLE;
+	        this.buffer = new Uint8Array(blockLen);
+	        this.view = (0, utils_ts_1.createView)(this.buffer);
+	    }
+	    update(data) {
+	        (0, utils_ts_1.aexists)(this);
+	        data = (0, utils_ts_1.toBytes)(data);
+	        (0, utils_ts_1.abytes)(data);
+	        const { view, buffer, blockLen } = this;
+	        const len = data.length;
+	        for (let pos = 0; pos < len;) {
+	            const take = Math.min(blockLen - this.pos, len - pos);
+	            // Fast path: we have at least one block in input, cast it to view and process
+	            if (take === blockLen) {
+	                const dataView = (0, utils_ts_1.createView)(data);
+	                for (; blockLen <= len - pos; pos += blockLen)
+	                    this.process(dataView, pos);
+	                continue;
+	            }
+	            buffer.set(data.subarray(pos, pos + take), this.pos);
+	            this.pos += take;
+	            pos += take;
+	            if (this.pos === blockLen) {
+	                this.process(view, 0);
+	                this.pos = 0;
+	            }
+	        }
+	        this.length += data.length;
+	        this.roundClean();
+	        return this;
+	    }
+	    digestInto(out) {
+	        (0, utils_ts_1.aexists)(this);
+	        (0, utils_ts_1.aoutput)(out, this);
+	        this.finished = true;
+	        // Padding
+	        // We can avoid allocation of buffer for padding completely if it
+	        // was previously not allocated here. But it won't change performance.
+	        const { buffer, view, blockLen, isLE } = this;
+	        let { pos } = this;
+	        // append the bit '1' to the message
+	        buffer[pos++] = 0b10000000;
+	        (0, utils_ts_1.clean)(this.buffer.subarray(pos));
+	        // we have less than padOffset left in buffer, so we cannot put length in
+	        // current block, need process it and pad again
+	        if (this.padOffset > blockLen - pos) {
+	            this.process(view, 0);
+	            pos = 0;
+	        }
+	        // Pad until full block byte with zeros
+	        for (let i = pos; i < blockLen; i++)
+	            buffer[i] = 0;
+	        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+	        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+	        // So we just write lowest 64 bits of that value.
+	        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+	        this.process(view, 0);
+	        const oview = (0, utils_ts_1.createView)(out);
+	        const len = this.outputLen;
+	        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+	        if (len % 4)
+	            throw new Error('_sha2: outputLen should be aligned to 32bit');
+	        const outLen = len / 4;
+	        const state = this.get();
+	        if (outLen > state.length)
+	            throw new Error('_sha2: outputLen bigger than state');
+	        for (let i = 0; i < outLen; i++)
+	            oview.setUint32(4 * i, state[i], isLE);
+	    }
+	    digest() {
+	        const { buffer, outputLen } = this;
+	        this.digestInto(buffer);
+	        const res = buffer.slice(0, outputLen);
+	        this.destroy();
+	        return res;
+	    }
+	    _cloneInto(to) {
+	        to || (to = new this.constructor());
+	        to.set(...this.get());
+	        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+	        to.destroyed = destroyed;
+	        to.finished = finished;
+	        to.length = length;
+	        to.pos = pos;
+	        if (length % blockLen)
+	            to.buffer.set(buffer);
+	        return to;
+	    }
+	    clone() {
+	        return this._cloneInto();
+	    }
+	}
+	_md.HashMD = HashMD;
+	/**
+	 * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+	 * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+	 */
+	/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+	_md.SHA256_IV = Uint32Array.from([
+	    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+	]);
+	/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */
+	_md.SHA224_IV = Uint32Array.from([
+	    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+	]);
+	/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
+	_md.SHA384_IV = Uint32Array.from([
+	    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
+	    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
+	]);
+	/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+	_md.SHA512_IV = Uint32Array.from([
+	    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
+	    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+	]);
+	
+	return _md;
 }
-var _ = {}, Ae;
-function $e() {
-  if (Ae) return _;
-  Ae = 1, Object.defineProperty(_, "__esModule", { value: !0 }), _.toBig = _.shrSL = _.shrSH = _.rotrSL = _.rotrSH = _.rotrBL = _.rotrBH = _.rotr32L = _.rotr32H = _.rotlSL = _.rotlSH = _.rotlBL = _.rotlBH = _.add5L = _.add5H = _.add4L = _.add4H = _.add3L = _.add3H = void 0, _.add = V, _.fromBig = n, _.split = H;
-  const e = /* @__PURE__ */ BigInt(2 ** 32 - 1), t = /* @__PURE__ */ BigInt(32);
-  function n(u, l = !1) {
-    return l ? { h: Number(u & e), l: Number(u >> t & e) } : { h: Number(u >> t & e) | 0, l: Number(u & e) | 0 };
-  }
-  function H(u, l = !1) {
-    const b = u.length;
-    let C = new Uint32Array(b), S = new Uint32Array(b);
-    for (let U = 0; U < b; U++) {
-      const { h: O, l: F } = n(u[U], l);
-      [C[U], S[U]] = [O, F];
-    }
-    return [C, S];
-  }
-  const y = (u, l) => BigInt(u >>> 0) << t | BigInt(l >>> 0);
-  _.toBig = y;
-  const w = (u, l, b) => u >>> b;
-  _.shrSH = w;
-  const a = (u, l, b) => u << 32 - b | l >>> b;
-  _.shrSL = a;
-  const c = (u, l, b) => u >>> b | l << 32 - b;
-  _.rotrSH = c;
-  const s = (u, l, b) => u << 32 - b | l >>> b;
-  _.rotrSL = s;
-  const o = (u, l, b) => u << 64 - b | l >>> b - 32;
-  _.rotrBH = o;
-  const i = (u, l, b) => u >>> b - 32 | l << 64 - b;
-  _.rotrBL = i;
-  const h = (u, l) => l;
-  _.rotr32H = h;
-  const m = (u, l) => u;
-  _.rotr32L = m;
-  const B = (u, l, b) => u << b | l >>> 32 - b;
-  _.rotlSH = B;
-  const f = (u, l, b) => l << b | u >>> 32 - b;
-  _.rotlSL = f;
-  const g = (u, l, b) => l << b - 32 | u >>> 64 - b;
-  _.rotlBH = g;
-  const d = (u, l, b) => u << b - 32 | l >>> 64 - b;
-  _.rotlBL = d;
-  function V(u, l, b, C) {
-    const S = (l >>> 0) + (C >>> 0);
-    return { h: u + b + (S / 2 ** 32 | 0) | 0, l: S | 0 };
-  }
-  const M = (u, l, b) => (u >>> 0) + (l >>> 0) + (b >>> 0);
-  _.add3L = M;
-  const x = (u, l, b, C) => l + b + C + (u / 2 ** 32 | 0) | 0;
-  _.add3H = x;
-  const R = (u, l, b, C) => (u >>> 0) + (l >>> 0) + (b >>> 0) + (C >>> 0);
-  _.add4L = R;
-  const A = (u, l, b, C, S) => l + b + C + S + (u / 2 ** 32 | 0) | 0;
-  _.add4H = A;
-  const I = (u, l, b, C, S) => (u >>> 0) + (l >>> 0) + (b >>> 0) + (C >>> 0) + (S >>> 0);
-  _.add5L = I;
-  const L = (u, l, b, C, S, U) => l + b + C + S + U + (u / 2 ** 32 | 0) | 0;
-  _.add5H = L;
-  const E = {
-    fromBig: n,
-    split: H,
-    toBig: y,
-    shrSH: w,
-    shrSL: a,
-    rotrSH: c,
-    rotrSL: s,
-    rotrBH: o,
-    rotrBL: i,
-    rotr32H: h,
-    rotr32L: m,
-    rotlSH: B,
-    rotlSL: f,
-    rotlBH: g,
-    rotlBL: d,
-    add: V,
-    add3L: M,
-    add3H: x,
-    add4L: R,
-    add4H: A,
-    add5H: L,
-    add5L: I
-  };
-  return _.default = E, _;
+
+var _u64 = {};
+
+var hasRequired_u64;
+
+function require_u64 () {
+	if (hasRequired_u64) return _u64;
+	hasRequired_u64 = 1;
+	Object.defineProperty(_u64, "__esModule", { value: true });
+	_u64.toBig = _u64.shrSL = _u64.shrSH = _u64.rotrSL = _u64.rotrSH = _u64.rotrBL = _u64.rotrBH = _u64.rotr32L = _u64.rotr32H = _u64.rotlSL = _u64.rotlSH = _u64.rotlBL = _u64.rotlBH = _u64.add5L = _u64.add5H = _u64.add4L = _u64.add4H = _u64.add3L = _u64.add3H = void 0;
+	_u64.add = add;
+	_u64.fromBig = fromBig;
+	_u64.split = split;
+	/**
+	 * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+	 * @todo re-check https://issues.chromium.org/issues/42212588
+	 * @module
+	 */
+	const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+	const _32n = /* @__PURE__ */ BigInt(32);
+	function fromBig(n, le = false) {
+	    if (le)
+	        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+	    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+	}
+	function split(lst, le = false) {
+	    const len = lst.length;
+	    let Ah = new Uint32Array(len);
+	    let Al = new Uint32Array(len);
+	    for (let i = 0; i < len; i++) {
+	        const { h, l } = fromBig(lst[i], le);
+	        [Ah[i], Al[i]] = [h, l];
+	    }
+	    return [Ah, Al];
+	}
+	const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+	_u64.toBig = toBig;
+	// for Shift in [0, 32)
+	const shrSH = (h, _l, s) => h >>> s;
+	_u64.shrSH = shrSH;
+	const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+	_u64.shrSL = shrSL;
+	// Right rotate for Shift in [1, 32)
+	const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+	_u64.rotrSH = rotrSH;
+	const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+	_u64.rotrSL = rotrSL;
+	// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+	const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+	_u64.rotrBH = rotrBH;
+	const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+	_u64.rotrBL = rotrBL;
+	// Right rotate for shift===32 (just swaps l&h)
+	const rotr32H = (_h, l) => l;
+	_u64.rotr32H = rotr32H;
+	const rotr32L = (h, _l) => h;
+	_u64.rotr32L = rotr32L;
+	// Left rotate for Shift in [1, 32)
+	const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+	_u64.rotlSH = rotlSH;
+	const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+	_u64.rotlSL = rotlSL;
+	// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+	const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+	_u64.rotlBH = rotlBH;
+	const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+	_u64.rotlBL = rotlBL;
+	// JS uses 32-bit signed integers for bitwise operations which means we cannot
+	// simple take carry out of low bit sum by shift, we need to use division.
+	function add(Ah, Al, Bh, Bl) {
+	    const l = (Al >>> 0) + (Bl >>> 0);
+	    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+	}
+	// Addition with more than 2 elements
+	const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+	_u64.add3L = add3L;
+	const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add3H = add3H;
+	const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+	_u64.add4L = add4L;
+	const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add4H = add4H;
+	const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+	_u64.add5L = add5L;
+	const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add5H = add5H;
+	// prettier-ignore
+	const u64 = {
+	    fromBig, split, toBig,
+	    shrSH, shrSL,
+	    rotrSH, rotrSL, rotrBH, rotrBL,
+	    rotr32H, rotr32L,
+	    rotlSH, rotlSL, rotlBH, rotlBL,
+	    add, add3L, add3H, add4L, add4H, add5H, add5L,
+	};
+	_u64.default = u64;
+	
+	return _u64;
 }
-var we;
-function ze() {
-  if (we) return T;
-  we = 1, Object.defineProperty(T, "__esModule", { value: !0 }), T.sha512_224 = T.sha512_256 = T.sha384 = T.sha512 = T.sha224 = T.sha256 = T.SHA512_256 = T.SHA512_224 = T.SHA384 = T.SHA512 = T.SHA224 = T.SHA256 = void 0;
-  const e = /* @__PURE__ */ Ne(), t = /* @__PURE__ */ $e(), n = /* @__PURE__ */ Ce(), H = /* @__PURE__ */ Uint32Array.from([
-    1116352408,
-    1899447441,
-    3049323471,
-    3921009573,
-    961987163,
-    1508970993,
-    2453635748,
-    2870763221,
-    3624381080,
-    310598401,
-    607225278,
-    1426881987,
-    1925078388,
-    2162078206,
-    2614888103,
-    3248222580,
-    3835390401,
-    4022224774,
-    264347078,
-    604807628,
-    770255983,
-    1249150122,
-    1555081692,
-    1996064986,
-    2554220882,
-    2821834349,
-    2952996808,
-    3210313671,
-    3336571891,
-    3584528711,
-    113926993,
-    338241895,
-    666307205,
-    773529912,
-    1294757372,
-    1396182291,
-    1695183700,
-    1986661051,
-    2177026350,
-    2456956037,
-    2730485921,
-    2820302411,
-    3259730800,
-    3345764771,
-    3516065817,
-    3600352804,
-    4094571909,
-    275423344,
-    430227734,
-    506948616,
-    659060556,
-    883997877,
-    958139571,
-    1322822218,
-    1537002063,
-    1747873779,
-    1955562222,
-    2024104815,
-    2227730452,
-    2361852424,
-    2428436474,
-    2756734187,
-    3204031479,
-    3329325298
-  ]), y = /* @__PURE__ */ new Uint32Array(64);
-  class w extends e.HashMD {
-    constructor(x = 32) {
-      super(64, x, 8, !1), this.A = e.SHA256_IV[0] | 0, this.B = e.SHA256_IV[1] | 0, this.C = e.SHA256_IV[2] | 0, this.D = e.SHA256_IV[3] | 0, this.E = e.SHA256_IV[4] | 0, this.F = e.SHA256_IV[5] | 0, this.G = e.SHA256_IV[6] | 0, this.H = e.SHA256_IV[7] | 0;
-    }
-    get() {
-      const { A: x, B: R, C: A, D: I, E: L, F: E, G: u, H: l } = this;
-      return [x, R, A, I, L, E, u, l];
-    }
-    // prettier-ignore
-    set(x, R, A, I, L, E, u, l) {
-      this.A = x | 0, this.B = R | 0, this.C = A | 0, this.D = I | 0, this.E = L | 0, this.F = E | 0, this.G = u | 0, this.H = l | 0;
-    }
-    process(x, R) {
-      for (let S = 0; S < 16; S++, R += 4)
-        y[S] = x.getUint32(R, !1);
-      for (let S = 16; S < 64; S++) {
-        const U = y[S - 15], O = y[S - 2], F = (0, n.rotr)(U, 7) ^ (0, n.rotr)(U, 18) ^ U >>> 3, q = (0, n.rotr)(O, 17) ^ (0, n.rotr)(O, 19) ^ O >>> 10;
-        y[S] = q + y[S - 7] + F + y[S - 16] | 0;
-      }
-      let { A, B: I, C: L, D: E, E: u, F: l, G: b, H: C } = this;
-      for (let S = 0; S < 64; S++) {
-        const U = (0, n.rotr)(u, 6) ^ (0, n.rotr)(u, 11) ^ (0, n.rotr)(u, 25), O = C + U + (0, e.Chi)(u, l, b) + H[S] + y[S] | 0, q = ((0, n.rotr)(A, 2) ^ (0, n.rotr)(A, 13) ^ (0, n.rotr)(A, 22)) + (0, e.Maj)(A, I, L) | 0;
-        C = b, b = l, l = u, u = E + O | 0, E = L, L = I, I = A, A = O + q | 0;
-      }
-      A = A + this.A | 0, I = I + this.B | 0, L = L + this.C | 0, E = E + this.D | 0, u = u + this.E | 0, l = l + this.F | 0, b = b + this.G | 0, C = C + this.H | 0, this.set(A, I, L, E, u, l, b, C);
-    }
-    roundClean() {
-      (0, n.clean)(y);
-    }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0), (0, n.clean)(this.buffer);
-    }
-  }
-  T.SHA256 = w;
-  class a extends w {
-    constructor() {
-      super(28), this.A = e.SHA224_IV[0] | 0, this.B = e.SHA224_IV[1] | 0, this.C = e.SHA224_IV[2] | 0, this.D = e.SHA224_IV[3] | 0, this.E = e.SHA224_IV[4] | 0, this.F = e.SHA224_IV[5] | 0, this.G = e.SHA224_IV[6] | 0, this.H = e.SHA224_IV[7] | 0;
-    }
-  }
-  T.SHA224 = a;
-  const c = t.split([
-    "0x428a2f98d728ae22",
-    "0x7137449123ef65cd",
-    "0xb5c0fbcfec4d3b2f",
-    "0xe9b5dba58189dbbc",
-    "0x3956c25bf348b538",
-    "0x59f111f1b605d019",
-    "0x923f82a4af194f9b",
-    "0xab1c5ed5da6d8118",
-    "0xd807aa98a3030242",
-    "0x12835b0145706fbe",
-    "0x243185be4ee4b28c",
-    "0x550c7dc3d5ffb4e2",
-    "0x72be5d74f27b896f",
-    "0x80deb1fe3b1696b1",
-    "0x9bdc06a725c71235",
-    "0xc19bf174cf692694",
-    "0xe49b69c19ef14ad2",
-    "0xefbe4786384f25e3",
-    "0x0fc19dc68b8cd5b5",
-    "0x240ca1cc77ac9c65",
-    "0x2de92c6f592b0275",
-    "0x4a7484aa6ea6e483",
-    "0x5cb0a9dcbd41fbd4",
-    "0x76f988da831153b5",
-    "0x983e5152ee66dfab",
-    "0xa831c66d2db43210",
-    "0xb00327c898fb213f",
-    "0xbf597fc7beef0ee4",
-    "0xc6e00bf33da88fc2",
-    "0xd5a79147930aa725",
-    "0x06ca6351e003826f",
-    "0x142929670a0e6e70",
-    "0x27b70a8546d22ffc",
-    "0x2e1b21385c26c926",
-    "0x4d2c6dfc5ac42aed",
-    "0x53380d139d95b3df",
-    "0x650a73548baf63de",
-    "0x766a0abb3c77b2a8",
-    "0x81c2c92e47edaee6",
-    "0x92722c851482353b",
-    "0xa2bfe8a14cf10364",
-    "0xa81a664bbc423001",
-    "0xc24b8b70d0f89791",
-    "0xc76c51a30654be30",
-    "0xd192e819d6ef5218",
-    "0xd69906245565a910",
-    "0xf40e35855771202a",
-    "0x106aa07032bbd1b8",
-    "0x19a4c116b8d2d0c8",
-    "0x1e376c085141ab53",
-    "0x2748774cdf8eeb99",
-    "0x34b0bcb5e19b48a8",
-    "0x391c0cb3c5c95a63",
-    "0x4ed8aa4ae3418acb",
-    "0x5b9cca4f7763e373",
-    "0x682e6ff3d6b2b8a3",
-    "0x748f82ee5defb2fc",
-    "0x78a5636f43172f60",
-    "0x84c87814a1f0ab72",
-    "0x8cc702081a6439ec",
-    "0x90befffa23631e28",
-    "0xa4506cebde82bde9",
-    "0xbef9a3f7b2c67915",
-    "0xc67178f2e372532b",
-    "0xca273eceea26619c",
-    "0xd186b8c721c0c207",
-    "0xeada7dd6cde0eb1e",
-    "0xf57d4f7fee6ed178",
-    "0x06f067aa72176fba",
-    "0x0a637dc5a2c898a6",
-    "0x113f9804bef90dae",
-    "0x1b710b35131c471b",
-    "0x28db77f523047d84",
-    "0x32caab7b40c72493",
-    "0x3c9ebe0a15c9bebc",
-    "0x431d67c49c100d4c",
-    "0x4cc5d4becb3e42b6",
-    "0x597f299cfc657e2a",
-    "0x5fcb6fab3ad6faec",
-    "0x6c44198c4a475817"
-  ].map((M) => BigInt(M))), s = c[0], o = c[1], i = /* @__PURE__ */ new Uint32Array(80), h = /* @__PURE__ */ new Uint32Array(80);
-  class m extends e.HashMD {
-    constructor(x = 64) {
-      super(128, x, 16, !1), this.Ah = e.SHA512_IV[0] | 0, this.Al = e.SHA512_IV[1] | 0, this.Bh = e.SHA512_IV[2] | 0, this.Bl = e.SHA512_IV[3] | 0, this.Ch = e.SHA512_IV[4] | 0, this.Cl = e.SHA512_IV[5] | 0, this.Dh = e.SHA512_IV[6] | 0, this.Dl = e.SHA512_IV[7] | 0, this.Eh = e.SHA512_IV[8] | 0, this.El = e.SHA512_IV[9] | 0, this.Fh = e.SHA512_IV[10] | 0, this.Fl = e.SHA512_IV[11] | 0, this.Gh = e.SHA512_IV[12] | 0, this.Gl = e.SHA512_IV[13] | 0, this.Hh = e.SHA512_IV[14] | 0, this.Hl = e.SHA512_IV[15] | 0;
-    }
-    // prettier-ignore
-    get() {
-      const { Ah: x, Al: R, Bh: A, Bl: I, Ch: L, Cl: E, Dh: u, Dl: l, Eh: b, El: C, Fh: S, Fl: U, Gh: O, Gl: F, Hh: q, Hl: j } = this;
-      return [x, R, A, I, L, E, u, l, b, C, S, U, O, F, q, j];
-    }
-    // prettier-ignore
-    set(x, R, A, I, L, E, u, l, b, C, S, U, O, F, q, j) {
-      this.Ah = x | 0, this.Al = R | 0, this.Bh = A | 0, this.Bl = I | 0, this.Ch = L | 0, this.Cl = E | 0, this.Dh = u | 0, this.Dl = l | 0, this.Eh = b | 0, this.El = C | 0, this.Fh = S | 0, this.Fl = U | 0, this.Gh = O | 0, this.Gl = F | 0, this.Hh = q | 0, this.Hl = j | 0;
-    }
-    process(x, R) {
-      for (let v = 0; v < 16; v++, R += 4)
-        i[v] = x.getUint32(R), h[v] = x.getUint32(R += 4);
-      for (let v = 16; v < 80; v++) {
-        const D = i[v - 15] | 0, k = h[v - 15] | 0, G = t.rotrSH(D, k, 1) ^ t.rotrSH(D, k, 8) ^ t.shrSH(D, k, 7), K = t.rotrSL(D, k, 1) ^ t.rotrSL(D, k, 8) ^ t.shrSL(D, k, 7), W = i[v - 2] | 0, N = h[v - 2] | 0, Y = t.rotrSH(W, N, 19) ^ t.rotrBH(W, N, 61) ^ t.shrSH(W, N, 6), re = t.rotrSL(W, N, 19) ^ t.rotrBL(W, N, 61) ^ t.shrSL(W, N, 6), Z = t.add4L(K, re, h[v - 7], h[v - 16]), ne = t.add4H(Z, G, Y, i[v - 7], i[v - 16]);
-        i[v] = ne | 0, h[v] = Z | 0;
-      }
-      let { Ah: A, Al: I, Bh: L, Bl: E, Ch: u, Cl: l, Dh: b, Dl: C, Eh: S, El: U, Fh: O, Fl: F, Gh: q, Gl: j, Hh: r, Hl: p } = this;
-      for (let v = 0; v < 80; v++) {
-        const D = t.rotrSH(S, U, 14) ^ t.rotrSH(S, U, 18) ^ t.rotrBH(S, U, 41), k = t.rotrSL(S, U, 14) ^ t.rotrSL(S, U, 18) ^ t.rotrBL(S, U, 41), G = S & O ^ ~S & q, K = U & F ^ ~U & j, W = t.add5L(p, k, K, o[v], h[v]), N = t.add5H(W, r, D, G, s[v], i[v]), Y = W | 0, re = t.rotrSH(A, I, 28) ^ t.rotrBH(A, I, 34) ^ t.rotrBH(A, I, 39), Z = t.rotrSL(A, I, 28) ^ t.rotrBL(A, I, 34) ^ t.rotrBL(A, I, 39), ne = A & L ^ A & u ^ L & u, Te = I & E ^ I & l ^ E & l;
-        r = q | 0, p = j | 0, q = O | 0, j = F | 0, O = S | 0, F = U | 0, { h: S, l: U } = t.add(b | 0, C | 0, N | 0, Y | 0), b = u | 0, C = l | 0, u = L | 0, l = E | 0, L = A | 0, E = I | 0;
-        const xe = t.add3L(Y, Z, Te);
-        A = t.add3H(xe, N, re, ne), I = xe | 0;
-      }
-      ({ h: A, l: I } = t.add(this.Ah | 0, this.Al | 0, A | 0, I | 0)), { h: L, l: E } = t.add(this.Bh | 0, this.Bl | 0, L | 0, E | 0), { h: u, l } = t.add(this.Ch | 0, this.Cl | 0, u | 0, l | 0), { h: b, l: C } = t.add(this.Dh | 0, this.Dl | 0, b | 0, C | 0), { h: S, l: U } = t.add(this.Eh | 0, this.El | 0, S | 0, U | 0), { h: O, l: F } = t.add(this.Fh | 0, this.Fl | 0, O | 0, F | 0), { h: q, l: j } = t.add(this.Gh | 0, this.Gl | 0, q | 0, j | 0), { h: r, l: p } = t.add(this.Hh | 0, this.Hl | 0, r | 0, p | 0), this.set(A, I, L, E, u, l, b, C, S, U, O, F, q, j, r, p);
-    }
-    roundClean() {
-      (0, n.clean)(i, h);
-    }
-    destroy() {
-      (0, n.clean)(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-    }
-  }
-  T.SHA512 = m;
-  class B extends m {
-    constructor() {
-      super(48), this.Ah = e.SHA384_IV[0] | 0, this.Al = e.SHA384_IV[1] | 0, this.Bh = e.SHA384_IV[2] | 0, this.Bl = e.SHA384_IV[3] | 0, this.Ch = e.SHA384_IV[4] | 0, this.Cl = e.SHA384_IV[5] | 0, this.Dh = e.SHA384_IV[6] | 0, this.Dl = e.SHA384_IV[7] | 0, this.Eh = e.SHA384_IV[8] | 0, this.El = e.SHA384_IV[9] | 0, this.Fh = e.SHA384_IV[10] | 0, this.Fl = e.SHA384_IV[11] | 0, this.Gh = e.SHA384_IV[12] | 0, this.Gl = e.SHA384_IV[13] | 0, this.Hh = e.SHA384_IV[14] | 0, this.Hl = e.SHA384_IV[15] | 0;
-    }
-  }
-  T.SHA384 = B;
-  const f = /* @__PURE__ */ Uint32Array.from([
-    2352822216,
-    424955298,
-    1944164710,
-    2312950998,
-    502970286,
-    855612546,
-    1738396948,
-    1479516111,
-    258812777,
-    2077511080,
-    2011393907,
-    79989058,
-    1067287976,
-    1780299464,
-    286451373,
-    2446758561
-  ]), g = /* @__PURE__ */ Uint32Array.from([
-    573645204,
-    4230739756,
-    2673172387,
-    3360449730,
-    596883563,
-    1867755857,
-    2520282905,
-    1497426621,
-    2519219938,
-    2827943907,
-    3193839141,
-    1401305490,
-    721525244,
-    746961066,
-    246885852,
-    2177182882
-  ]);
-  class d extends m {
-    constructor() {
-      super(28), this.Ah = f[0] | 0, this.Al = f[1] | 0, this.Bh = f[2] | 0, this.Bl = f[3] | 0, this.Ch = f[4] | 0, this.Cl = f[5] | 0, this.Dh = f[6] | 0, this.Dl = f[7] | 0, this.Eh = f[8] | 0, this.El = f[9] | 0, this.Fh = f[10] | 0, this.Fl = f[11] | 0, this.Gh = f[12] | 0, this.Gl = f[13] | 0, this.Hh = f[14] | 0, this.Hl = f[15] | 0;
-    }
-  }
-  T.SHA512_224 = d;
-  class V extends m {
-    constructor() {
-      super(32), this.Ah = g[0] | 0, this.Al = g[1] | 0, this.Bh = g[2] | 0, this.Bl = g[3] | 0, this.Ch = g[4] | 0, this.Cl = g[5] | 0, this.Dh = g[6] | 0, this.Dl = g[7] | 0, this.Eh = g[8] | 0, this.El = g[9] | 0, this.Fh = g[10] | 0, this.Fl = g[11] | 0, this.Gh = g[12] | 0, this.Gl = g[13] | 0, this.Hh = g[14] | 0, this.Hl = g[15] | 0;
-    }
-  }
-  return T.SHA512_256 = V, T.sha256 = (0, n.createHasher)(() => new w()), T.sha224 = (0, n.createHasher)(() => new a()), T.sha512 = (0, n.createHasher)(() => new m()), T.sha384 = (0, n.createHasher)(() => new B()), T.sha512_256 = (0, n.createHasher)(() => new V()), T.sha512_224 = (0, n.createHasher)(() => new d()), T;
+
+var hasRequiredSha2;
+
+function requireSha2 () {
+	if (hasRequiredSha2) return sha2;
+	hasRequiredSha2 = 1;
+	Object.defineProperty(sha2, "__esModule", { value: true });
+	sha2.sha512_224 = sha2.sha512_256 = sha2.sha384 = sha2.sha512 = sha2.sha224 = sha2.sha256 = sha2.SHA512_256 = sha2.SHA512_224 = sha2.SHA384 = sha2.SHA512 = sha2.SHA224 = sha2.SHA256 = void 0;
+	/**
+	 * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+	 * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+	 * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+	 * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+	 * @module
+	 */
+	const _md_ts_1 = /*@__PURE__*/ require_md();
+	const u64 = /*@__PURE__*/ require_u64();
+	const utils_ts_1 = /*@__PURE__*/ requireUtils();
+	/**
+	 * Round constants:
+	 * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+	 */
+	// prettier-ignore
+	const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	]);
+	/** Reusable temporary buffer. "W" comes straight from spec. */
+	const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+	class SHA256 extends _md_ts_1.HashMD {
+	    constructor(outputLen = 32) {
+	        super(64, outputLen, 8, false);
+	        // We cannot use array here since array allows indexing by variable
+	        // which means optimizer/compiler cannot use registers.
+	        this.A = _md_ts_1.SHA256_IV[0] | 0;
+	        this.B = _md_ts_1.SHA256_IV[1] | 0;
+	        this.C = _md_ts_1.SHA256_IV[2] | 0;
+	        this.D = _md_ts_1.SHA256_IV[3] | 0;
+	        this.E = _md_ts_1.SHA256_IV[4] | 0;
+	        this.F = _md_ts_1.SHA256_IV[5] | 0;
+	        this.G = _md_ts_1.SHA256_IV[6] | 0;
+	        this.H = _md_ts_1.SHA256_IV[7] | 0;
+	    }
+	    get() {
+	        const { A, B, C, D, E, F, G, H } = this;
+	        return [A, B, C, D, E, F, G, H];
+	    }
+	    // prettier-ignore
+	    set(A, B, C, D, E, F, G, H) {
+	        this.A = A | 0;
+	        this.B = B | 0;
+	        this.C = C | 0;
+	        this.D = D | 0;
+	        this.E = E | 0;
+	        this.F = F | 0;
+	        this.G = G | 0;
+	        this.H = H | 0;
+	    }
+	    process(view, offset) {
+	        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+	        for (let i = 0; i < 16; i++, offset += 4)
+	            SHA256_W[i] = view.getUint32(offset, false);
+	        for (let i = 16; i < 64; i++) {
+	            const W15 = SHA256_W[i - 15];
+	            const W2 = SHA256_W[i - 2];
+	            const s0 = (0, utils_ts_1.rotr)(W15, 7) ^ (0, utils_ts_1.rotr)(W15, 18) ^ (W15 >>> 3);
+	            const s1 = (0, utils_ts_1.rotr)(W2, 17) ^ (0, utils_ts_1.rotr)(W2, 19) ^ (W2 >>> 10);
+	            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+	        }
+	        // Compression function main loop, 64 rounds
+	        let { A, B, C, D, E, F, G, H } = this;
+	        for (let i = 0; i < 64; i++) {
+	            const sigma1 = (0, utils_ts_1.rotr)(E, 6) ^ (0, utils_ts_1.rotr)(E, 11) ^ (0, utils_ts_1.rotr)(E, 25);
+	            const T1 = (H + sigma1 + (0, _md_ts_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+	            const sigma0 = (0, utils_ts_1.rotr)(A, 2) ^ (0, utils_ts_1.rotr)(A, 13) ^ (0, utils_ts_1.rotr)(A, 22);
+	            const T2 = (sigma0 + (0, _md_ts_1.Maj)(A, B, C)) | 0;
+	            H = G;
+	            G = F;
+	            F = E;
+	            E = (D + T1) | 0;
+	            D = C;
+	            C = B;
+	            B = A;
+	            A = (T1 + T2) | 0;
+	        }
+	        // Add the compressed chunk to the current hash value
+	        A = (A + this.A) | 0;
+	        B = (B + this.B) | 0;
+	        C = (C + this.C) | 0;
+	        D = (D + this.D) | 0;
+	        E = (E + this.E) | 0;
+	        F = (F + this.F) | 0;
+	        G = (G + this.G) | 0;
+	        H = (H + this.H) | 0;
+	        this.set(A, B, C, D, E, F, G, H);
+	    }
+	    roundClean() {
+	        (0, utils_ts_1.clean)(SHA256_W);
+	    }
+	    destroy() {
+	        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+	        (0, utils_ts_1.clean)(this.buffer);
+	    }
+	}
+	sha2.SHA256 = SHA256;
+	class SHA224 extends SHA256 {
+	    constructor() {
+	        super(28);
+	        this.A = _md_ts_1.SHA224_IV[0] | 0;
+	        this.B = _md_ts_1.SHA224_IV[1] | 0;
+	        this.C = _md_ts_1.SHA224_IV[2] | 0;
+	        this.D = _md_ts_1.SHA224_IV[3] | 0;
+	        this.E = _md_ts_1.SHA224_IV[4] | 0;
+	        this.F = _md_ts_1.SHA224_IV[5] | 0;
+	        this.G = _md_ts_1.SHA224_IV[6] | 0;
+	        this.H = _md_ts_1.SHA224_IV[7] | 0;
+	    }
+	}
+	sha2.SHA224 = SHA224;
+	// SHA2-512 is slower than sha256 in js because u64 operations are slow.
+	// Round contants
+	// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409
+	// prettier-ignore
+	const K512 = /* @__PURE__ */ (() => u64.split([
+	    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+	    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+	    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+	    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+	    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+	    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+	    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+	    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+	    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+	    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+	    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+	    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+	    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+	    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+	    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+	    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+	    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+	    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+	    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+	    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+	].map(n => BigInt(n))))();
+	const SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+	const SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+	// Reusable temporary buffers
+	const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+	const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+	class SHA512 extends _md_ts_1.HashMD {
+	    constructor(outputLen = 64) {
+	        super(128, outputLen, 16, false);
+	        // We cannot use array here since array allows indexing by variable
+	        // which means optimizer/compiler cannot use registers.
+	        // h -- high 32 bits, l -- low 32 bits
+	        this.Ah = _md_ts_1.SHA512_IV[0] | 0;
+	        this.Al = _md_ts_1.SHA512_IV[1] | 0;
+	        this.Bh = _md_ts_1.SHA512_IV[2] | 0;
+	        this.Bl = _md_ts_1.SHA512_IV[3] | 0;
+	        this.Ch = _md_ts_1.SHA512_IV[4] | 0;
+	        this.Cl = _md_ts_1.SHA512_IV[5] | 0;
+	        this.Dh = _md_ts_1.SHA512_IV[6] | 0;
+	        this.Dl = _md_ts_1.SHA512_IV[7] | 0;
+	        this.Eh = _md_ts_1.SHA512_IV[8] | 0;
+	        this.El = _md_ts_1.SHA512_IV[9] | 0;
+	        this.Fh = _md_ts_1.SHA512_IV[10] | 0;
+	        this.Fl = _md_ts_1.SHA512_IV[11] | 0;
+	        this.Gh = _md_ts_1.SHA512_IV[12] | 0;
+	        this.Gl = _md_ts_1.SHA512_IV[13] | 0;
+	        this.Hh = _md_ts_1.SHA512_IV[14] | 0;
+	        this.Hl = _md_ts_1.SHA512_IV[15] | 0;
+	    }
+	    // prettier-ignore
+	    get() {
+	        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+	        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+	    }
+	    // prettier-ignore
+	    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+	        this.Ah = Ah | 0;
+	        this.Al = Al | 0;
+	        this.Bh = Bh | 0;
+	        this.Bl = Bl | 0;
+	        this.Ch = Ch | 0;
+	        this.Cl = Cl | 0;
+	        this.Dh = Dh | 0;
+	        this.Dl = Dl | 0;
+	        this.Eh = Eh | 0;
+	        this.El = El | 0;
+	        this.Fh = Fh | 0;
+	        this.Fl = Fl | 0;
+	        this.Gh = Gh | 0;
+	        this.Gl = Gl | 0;
+	        this.Hh = Hh | 0;
+	        this.Hl = Hl | 0;
+	    }
+	    process(view, offset) {
+	        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+	        for (let i = 0; i < 16; i++, offset += 4) {
+	            SHA512_W_H[i] = view.getUint32(offset);
+	            SHA512_W_L[i] = view.getUint32((offset += 4));
+	        }
+	        for (let i = 16; i < 80; i++) {
+	            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+	            const W15h = SHA512_W_H[i - 15] | 0;
+	            const W15l = SHA512_W_L[i - 15] | 0;
+	            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+	            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+	            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+	            const W2h = SHA512_W_H[i - 2] | 0;
+	            const W2l = SHA512_W_L[i - 2] | 0;
+	            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+	            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+	            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+	            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+	            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+	            SHA512_W_H[i] = SUMh | 0;
+	            SHA512_W_L[i] = SUMl | 0;
+	        }
+	        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+	        // Compression function main loop, 80 rounds
+	        for (let i = 0; i < 80; i++) {
+	            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+	            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+	            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+	            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+	            const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+	            const CHIl = (El & Fl) ^ (~El & Gl);
+	            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+	            // prettier-ignore
+	            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+	            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+	            const T1l = T1ll | 0;
+	            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+	            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+	            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+	            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+	            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+	            Hh = Gh | 0;
+	            Hl = Gl | 0;
+	            Gh = Fh | 0;
+	            Gl = Fl | 0;
+	            Fh = Eh | 0;
+	            Fl = El | 0;
+	            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+	            Dh = Ch | 0;
+	            Dl = Cl | 0;
+	            Ch = Bh | 0;
+	            Cl = Bl | 0;
+	            Bh = Ah | 0;
+	            Bl = Al | 0;
+	            const All = u64.add3L(T1l, sigma0l, MAJl);
+	            Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+	            Al = All | 0;
+	        }
+	        // Add the compressed chunk to the current hash value
+	        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+	        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+	        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+	        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+	        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+	        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+	        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+	        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+	        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	    }
+	    roundClean() {
+	        (0, utils_ts_1.clean)(SHA512_W_H, SHA512_W_L);
+	    }
+	    destroy() {
+	        (0, utils_ts_1.clean)(this.buffer);
+	        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	    }
+	}
+	sha2.SHA512 = SHA512;
+	class SHA384 extends SHA512 {
+	    constructor() {
+	        super(48);
+	        this.Ah = _md_ts_1.SHA384_IV[0] | 0;
+	        this.Al = _md_ts_1.SHA384_IV[1] | 0;
+	        this.Bh = _md_ts_1.SHA384_IV[2] | 0;
+	        this.Bl = _md_ts_1.SHA384_IV[3] | 0;
+	        this.Ch = _md_ts_1.SHA384_IV[4] | 0;
+	        this.Cl = _md_ts_1.SHA384_IV[5] | 0;
+	        this.Dh = _md_ts_1.SHA384_IV[6] | 0;
+	        this.Dl = _md_ts_1.SHA384_IV[7] | 0;
+	        this.Eh = _md_ts_1.SHA384_IV[8] | 0;
+	        this.El = _md_ts_1.SHA384_IV[9] | 0;
+	        this.Fh = _md_ts_1.SHA384_IV[10] | 0;
+	        this.Fl = _md_ts_1.SHA384_IV[11] | 0;
+	        this.Gh = _md_ts_1.SHA384_IV[12] | 0;
+	        this.Gl = _md_ts_1.SHA384_IV[13] | 0;
+	        this.Hh = _md_ts_1.SHA384_IV[14] | 0;
+	        this.Hl = _md_ts_1.SHA384_IV[15] | 0;
+	    }
+	}
+	sha2.SHA384 = SHA384;
+	/**
+	 * Truncated SHA512/256 and SHA512/224.
+	 * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as "intermediary" IV of SHA512/t.
+	 * Then t hashes string to produce result IV.
+	 * See `test/misc/sha2-gen-iv.js`.
+	 */
+	/** SHA512/224 IV */
+	const T224_IV = /* @__PURE__ */ Uint32Array.from([
+	    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,
+	    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,
+	]);
+	/** SHA512/256 IV */
+	const T256_IV = /* @__PURE__ */ Uint32Array.from([
+	    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,
+	    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,
+	]);
+	class SHA512_224 extends SHA512 {
+	    constructor() {
+	        super(28);
+	        this.Ah = T224_IV[0] | 0;
+	        this.Al = T224_IV[1] | 0;
+	        this.Bh = T224_IV[2] | 0;
+	        this.Bl = T224_IV[3] | 0;
+	        this.Ch = T224_IV[4] | 0;
+	        this.Cl = T224_IV[5] | 0;
+	        this.Dh = T224_IV[6] | 0;
+	        this.Dl = T224_IV[7] | 0;
+	        this.Eh = T224_IV[8] | 0;
+	        this.El = T224_IV[9] | 0;
+	        this.Fh = T224_IV[10] | 0;
+	        this.Fl = T224_IV[11] | 0;
+	        this.Gh = T224_IV[12] | 0;
+	        this.Gl = T224_IV[13] | 0;
+	        this.Hh = T224_IV[14] | 0;
+	        this.Hl = T224_IV[15] | 0;
+	    }
+	}
+	sha2.SHA512_224 = SHA512_224;
+	class SHA512_256 extends SHA512 {
+	    constructor() {
+	        super(32);
+	        this.Ah = T256_IV[0] | 0;
+	        this.Al = T256_IV[1] | 0;
+	        this.Bh = T256_IV[2] | 0;
+	        this.Bl = T256_IV[3] | 0;
+	        this.Ch = T256_IV[4] | 0;
+	        this.Cl = T256_IV[5] | 0;
+	        this.Dh = T256_IV[6] | 0;
+	        this.Dl = T256_IV[7] | 0;
+	        this.Eh = T256_IV[8] | 0;
+	        this.El = T256_IV[9] | 0;
+	        this.Fh = T256_IV[10] | 0;
+	        this.Fl = T256_IV[11] | 0;
+	        this.Gh = T256_IV[12] | 0;
+	        this.Gl = T256_IV[13] | 0;
+	        this.Hh = T256_IV[14] | 0;
+	        this.Hl = T256_IV[15] | 0;
+	    }
+	}
+	sha2.SHA512_256 = SHA512_256;
+	/**
+	 * SHA2-256 hash function from RFC 4634.
+	 *
+	 * It is the fastest JS hash, even faster than Blake3.
+	 * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+	 * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+	 */
+	sha2.sha256 = (0, utils_ts_1.createHasher)(() => new SHA256());
+	/** SHA2-224 hash function from RFC 4634 */
+	sha2.sha224 = (0, utils_ts_1.createHasher)(() => new SHA224());
+	/** SHA2-512 hash function from RFC 4634. */
+	sha2.sha512 = (0, utils_ts_1.createHasher)(() => new SHA512());
+	/** SHA2-384 hash function from RFC 4634. */
+	sha2.sha384 = (0, utils_ts_1.createHasher)(() => new SHA384());
+	/**
+	 * SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks.
+	 * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+	 */
+	sha2.sha512_256 = (0, utils_ts_1.createHasher)(() => new SHA512_256());
+	/**
+	 * SHA2-512/224 "truncated" hash function, with improved resistance to length extension attacks.
+	 * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+	 */
+	sha2.sha512_224 = (0, utils_ts_1.createHasher)(() => new SHA512_224());
+	
+	return sha2;
 }
-var ge;
-function Ke() {
-  if (ge) return $;
-  ge = 1, Object.defineProperty($, "__esModule", { value: !0 }), $.sha224 = $.SHA224 = $.sha256 = $.SHA256 = void 0;
-  const e = /* @__PURE__ */ ze();
-  return $.SHA256 = e.SHA256, $.sha256 = e.sha256, $.SHA224 = e.SHA224, $.sha224 = e.sha224, $;
+
+var hasRequiredSha256;
+
+function requireSha256 () {
+	if (hasRequiredSha256) return sha256;
+	hasRequiredSha256 = 1;
+	Object.defineProperty(sha256, "__esModule", { value: true });
+	sha256.sha224 = sha256.SHA224 = sha256.sha256 = sha256.SHA256 = void 0;
+	/**
+	 * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+	 *
+	 * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+	 * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+	 *
+	 * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+	 * @module
+	 * @deprecated
+	 */
+	const sha2_ts_1 = /*@__PURE__*/ requireSha2();
+	/** @deprecated Use import from `noble/hashes/sha2` module */
+	sha256.SHA256 = sha2_ts_1.SHA256;
+	/** @deprecated Use import from `noble/hashes/sha2` module */
+	sha256.sha256 = sha2_ts_1.sha256;
+	/** @deprecated Use import from `noble/hashes/sha2` module */
+	sha256.SHA224 = sha2_ts_1.SHA224;
+	/** @deprecated Use import from `noble/hashes/sha2` module */
+	sha256.sha224 = sha2_ts_1.sha224;
+	
+	return sha256;
 }
-var oe, ve;
-function Xe() {
-  if (ve) return oe;
-  ve = 1;
-  function e(t) {
-    if (t.length >= 255)
-      throw new TypeError("Alphabet too long");
-    for (var n = new Uint8Array(256), H = 0; H < n.length; H++)
-      n[H] = 255;
-    for (var y = 0; y < t.length; y++) {
-      var w = t.charAt(y), a = w.charCodeAt(0);
-      if (n[a] !== 255)
-        throw new TypeError(w + " is ambiguous");
-      n[a] = y;
-    }
-    var c = t.length, s = t.charAt(0), o = Math.log(c) / Math.log(256), i = Math.log(256) / Math.log(c);
-    function h(f) {
-      if (f instanceof Uint8Array || (ArrayBuffer.isView(f) ? f = new Uint8Array(f.buffer, f.byteOffset, f.byteLength) : Array.isArray(f) && (f = Uint8Array.from(f))), !(f instanceof Uint8Array))
-        throw new TypeError("Expected Uint8Array");
-      if (f.length === 0)
-        return "";
-      for (var g = 0, d = 0, V = 0, M = f.length; V !== M && f[V] === 0; )
-        V++, g++;
-      for (var x = (M - V) * i + 1 >>> 0, R = new Uint8Array(x); V !== M; ) {
-        for (var A = f[V], I = 0, L = x - 1; (A !== 0 || I < d) && L !== -1; L--, I++)
-          A += 256 * R[L] >>> 0, R[L] = A % c >>> 0, A = A / c >>> 0;
-        if (A !== 0)
-          throw new Error("Non-zero carry");
-        d = I, V++;
-      }
-      for (var E = x - d; E !== x && R[E] === 0; )
-        E++;
-      for (var u = s.repeat(g); E < x; ++E)
-        u += t.charAt(R[E]);
-      return u;
-    }
-    function m(f) {
-      if (typeof f != "string")
-        throw new TypeError("Expected String");
-      if (f.length === 0)
-        return new Uint8Array();
-      for (var g = 0, d = 0, V = 0; f[g] === s; )
-        d++, g++;
-      for (var M = (f.length - g) * o + 1 >>> 0, x = new Uint8Array(M); f[g]; ) {
-        var R = f.charCodeAt(g);
-        if (R > 255)
-          return;
-        var A = n[R];
-        if (A === 255)
-          return;
-        for (var I = 0, L = M - 1; (A !== 0 || I < V) && L !== -1; L--, I++)
-          A += c * x[L] >>> 0, x[L] = A % 256 >>> 0, A = A / 256 >>> 0;
-        if (A !== 0)
-          throw new Error("Non-zero carry");
-        V = I, g++;
-      }
-      for (var E = M - V; E !== M && x[E] === 0; )
-        E++;
-      for (var u = new Uint8Array(d + (M - E)), l = d; E !== M; )
-        u[l++] = x[E++];
-      return u;
-    }
-    function B(f) {
-      var g = m(f);
-      if (g)
-        return g;
-      throw new Error("Non-base" + c + " character");
-    }
-    return {
-      encode: h,
-      decodeUnsafe: m,
-      decode: B
-    };
-  }
-  return oe = e, oe;
+
+var src;
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	// base-x encoding / decoding
+	// Copyright (c) 2018 base-x contributors
+	// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+	// Distributed under the MIT software license, see the accompanying
+	// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+	function base (ALPHABET) {
+	  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+	  var BASE_MAP = new Uint8Array(256);
+	  for (var j = 0; j < BASE_MAP.length; j++) {
+	    BASE_MAP[j] = 255;
+	  }
+	  for (var i = 0; i < ALPHABET.length; i++) {
+	    var x = ALPHABET.charAt(i);
+	    var xc = x.charCodeAt(0);
+	    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+	    BASE_MAP[xc] = i;
+	  }
+	  var BASE = ALPHABET.length;
+	  var LEADER = ALPHABET.charAt(0);
+	  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+	  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+	  function encode (source) {
+	    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
+	      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+	    } else if (Array.isArray(source)) {
+	      source = Uint8Array.from(source);
+	    }
+	    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+	    if (source.length === 0) { return '' }
+	        // Skip & count leading zeroes.
+	    var zeroes = 0;
+	    var length = 0;
+	    var pbegin = 0;
+	    var pend = source.length;
+	    while (pbegin !== pend && source[pbegin] === 0) {
+	      pbegin++;
+	      zeroes++;
+	    }
+	        // Allocate enough space in big-endian base58 representation.
+	    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+	    var b58 = new Uint8Array(size);
+	        // Process the bytes.
+	    while (pbegin !== pend) {
+	      var carry = source[pbegin];
+	            // Apply "b58 = b58 * 256 + ch".
+	      var i = 0;
+	      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+	        carry += (256 * b58[it1]) >>> 0;
+	        b58[it1] = (carry % BASE) >>> 0;
+	        carry = (carry / BASE) >>> 0;
+	      }
+	      if (carry !== 0) { throw new Error('Non-zero carry') }
+	      length = i;
+	      pbegin++;
+	    }
+	        // Skip leading zeroes in base58 result.
+	    var it2 = size - length;
+	    while (it2 !== size && b58[it2] === 0) {
+	      it2++;
+	    }
+	        // Translate the result into a string.
+	    var str = LEADER.repeat(zeroes);
+	    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
+	    return str
+	  }
+	  function decodeUnsafe (source) {
+	    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+	    if (source.length === 0) { return new Uint8Array() }
+	    var psz = 0;
+	        // Skip and count leading '1's.
+	    var zeroes = 0;
+	    var length = 0;
+	    while (source[psz] === LEADER) {
+	      zeroes++;
+	      psz++;
+	    }
+	        // Allocate enough space in big-endian base256 representation.
+	    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+	    var b256 = new Uint8Array(size);
+	        // Process the characters.
+	    while (source[psz]) {
+	            // Find code of next character
+	      var charCode = source.charCodeAt(psz);
+	            // Base map can not be indexed using char code
+	      if (charCode > 255) { return }
+	            // Decode character
+	      var carry = BASE_MAP[charCode];
+	            // Invalid character
+	      if (carry === 255) { return }
+	      var i = 0;
+	      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+	        carry += (BASE * b256[it3]) >>> 0;
+	        b256[it3] = (carry % 256) >>> 0;
+	        carry = (carry / 256) >>> 0;
+	      }
+	      if (carry !== 0) { throw new Error('Non-zero carry') }
+	      length = i;
+	      psz++;
+	    }
+	        // Skip leading zeroes in b256.
+	    var it4 = size - length;
+	    while (it4 !== size && b256[it4] === 0) {
+	      it4++;
+	    }
+	    var vch = new Uint8Array(zeroes + (size - it4));
+	    var j = zeroes;
+	    while (it4 !== size) {
+	      vch[j++] = b256[it4++];
+	    }
+	    return vch
+	  }
+	  function decode (string) {
+	    var buffer = decodeUnsafe(string);
+	    if (buffer) { return buffer }
+	    throw new Error('Non-base' + BASE + ' character')
+	  }
+	  return {
+	    encode: encode,
+	    decodeUnsafe: decodeUnsafe,
+	    decode: decode
+	  }
+	}
+	src = base;
+	return src;
 }
-var ce, Se;
-function Je() {
-  return Se || (Se = 1, ce = Xe()("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")), ce;
+
+var bs58;
+var hasRequiredBs58;
+
+function requireBs58 () {
+	if (hasRequiredBs58) return bs58;
+	hasRequiredBs58 = 1;
+	const basex = requireSrc();
+	const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+	bs58 = basex(ALPHABET);
+	return bs58;
 }
-var ae, _e;
-function Qe() {
-  if (_e) return ae;
-  _e = 1;
-  var e = Je();
-  return ae = function(t) {
-    function n(a) {
-      var c = Uint8Array.from(a), s = t(c), o = c.length + 4, i = new Uint8Array(o);
-      return i.set(c, 0), i.set(s.subarray(0, 4), c.length), e.encode(i, o);
-    }
-    function H(a) {
-      var c = a.slice(0, -4), s = a.slice(-4), o = t(c);
-      if (!(s[0] ^ o[0] | s[1] ^ o[1] | s[2] ^ o[2] | s[3] ^ o[3]))
-        return c;
-    }
-    function y(a) {
-      var c = e.decodeUnsafe(a);
-      if (c)
-        return H(c);
-    }
-    function w(a) {
-      var c = e.decode(a), s = H(c);
-      if (!s) throw new Error("Invalid checksum");
-      return s;
-    }
-    return {
-      encode: n,
-      decode: w,
-      decodeUnsafe: y
-    };
-  }, ae;
+
+var base;
+var hasRequiredBase;
+
+function requireBase () {
+	if (hasRequiredBase) return base;
+	hasRequiredBase = 1;
+
+	var base58 = requireBs58();
+
+	base = function (checksumFn) {
+	  // Encode a buffer as a base58-check encoded string
+	  function encode (payload) {
+	    var payloadU8 = Uint8Array.from(payload);
+	    var checksum = checksumFn(payloadU8);
+	    var length = payloadU8.length + 4;
+	    var both = new Uint8Array(length);
+	    both.set(payloadU8, 0);
+	    both.set(checksum.subarray(0, 4), payloadU8.length);
+	    return base58.encode(both, length)
+	  }
+
+	  function decodeRaw (buffer) {
+	    var payload = buffer.slice(0, -4);
+	    var checksum = buffer.slice(-4);
+	    var newChecksum = checksumFn(payload);
+
+	    if (checksum[0] ^ newChecksum[0] |
+	        checksum[1] ^ newChecksum[1] |
+	        checksum[2] ^ newChecksum[2] |
+	        checksum[3] ^ newChecksum[3]) return
+
+	    return payload
+	  }
+
+	  // Decode a base58-check encoded string to a buffer, no result if checksum is wrong
+	  function decodeUnsafe (string) {
+	    var buffer = base58.decodeUnsafe(string);
+	    if (!buffer) return
+
+	    return decodeRaw(buffer)
+	  }
+
+	  function decode (string) {
+	    var buffer = base58.decode(string);
+	    var payload = decodeRaw(buffer);
+	    if (!payload) throw new Error('Invalid checksum')
+	    return payload
+	  }
+
+	  return {
+	    encode: encode,
+	    decode: decode,
+	    decodeUnsafe: decodeUnsafe
+	  }
+	};
+	return base;
 }
-var ie, me;
-function Ye() {
-  if (me) return ie;
-  me = 1;
-  var { sha256: e } = /* @__PURE__ */ Ke(), t = Qe();
-  function n(H) {
-    return e(e(H));
-  }
-  return ie = t(n), ie;
+
+var bs58check$1;
+var hasRequiredBs58check;
+
+function requireBs58check () {
+	if (hasRequiredBs58check) return bs58check$1;
+	hasRequiredBs58check = 1;
+
+	var { sha256 } = /*@__PURE__*/ requireSha256();
+	var bs58checkBase = requireBase();
+
+	// SHA256(SHA256(buffer))
+	function sha256x2 (buffer) {
+	  return sha256(sha256(buffer))
+	}
+
+	bs58check$1 = bs58checkBase(sha256x2);
+	return bs58check$1;
 }
-var Ze = Ye();
-const Q = /* @__PURE__ */ be(Ze), et = (e) => Array.from(e, (t) => t.toString(16).padStart(2, "0")).join(""), ee = "automerge:", tt = (e) => {
-  const [t, n, ...H] = e.split("#");
-  if (H.length > 0)
-    throw new Error("Invalid URL: contains multiple heads sections");
-  const y = new RegExp(`^${ee}(\\w+)$`), [, w] = t.match(y) || [], a = w, c = Re(a);
-  if (!c)
-    throw new Error("Invalid document URL: " + e);
-  if (n === void 0)
-    return { binaryDocumentId: c, documentId: a };
-  const s = n === "" ? [] : n.split("|"), o = s.map((i) => {
-    try {
-      return et(Q.decode(i));
-    } catch {
-      throw new Error(`Invalid head in URL: ${i}`);
-    }
-  });
-  return { binaryDocumentId: c, hexHeads: o, documentId: a, heads: s };
-}, De = (e) => {
-  if (e instanceof Uint8Array || typeof e == "string")
-    return ee + (e instanceof Uint8Array ? Ie(e) : e);
-  const { documentId: t, heads: n = void 0 } = e;
-  if (t === void 0)
-    throw new Error("Invalid documentId: " + t);
-  const H = t instanceof Uint8Array ? Ie(t) : t;
-  let y = `${ee}${H}`;
-  return n !== void 0 && (n.forEach((w) => {
+
+var bs58checkExports = requireBs58check();
+const bs58check = /*@__PURE__*/getDefaultExportFromCjs(bs58checkExports);
+
+const uint8ArrayToHexString = (data) => {
+    return Array.from(data, byte => byte.toString(16).padStart(2, "0")).join("");
+};
+
+const urlPrefix = "automerge:";
+/** Given an Automerge URL, returns the DocumentId in both base58check-encoded form and binary form */
+const parseAutomergeUrl = (url) => {
+    const [baseUrl, headsSection, ...rest] = url.split("#");
+    if (rest.length > 0) {
+        throw new Error("Invalid URL: contains multiple heads sections");
+    }
+    const regex = new RegExp(`^${urlPrefix}(\\w+)$`);
+    const [, docMatch] = baseUrl.match(regex) || [];
+    const documentId = docMatch;
+    const binaryDocumentId = documentIdToBinary(documentId);
+    if (!binaryDocumentId)
+        throw new Error("Invalid document URL: " + url);
+    if (headsSection === undefined)
+        return { binaryDocumentId, documentId };
+    const heads = (headsSection === "" ? [] : headsSection.split("|"));
+    const hexHeads = heads.map(head => {
+        try {
+            return uint8ArrayToHexString(bs58check.decode(head));
+        }
+        catch (e) {
+            throw new Error(`Invalid head in URL: ${head}`);
+        }
+    });
+    return { binaryDocumentId, hexHeads, documentId, heads };
+};
+/**
+ * Given a documentId in either binary or base58check-encoded form, returns an Automerge URL.
+ * Throws on invalid input.
+ */
+const stringifyAutomergeUrl = (arg) => {
+    if (arg instanceof Uint8Array || typeof arg === "string") {
+        return (urlPrefix +
+            (arg instanceof Uint8Array
+                ? binaryToDocumentId(arg)
+                : arg));
+    }
+    const { documentId, heads = undefined } = arg;
+    if (documentId === undefined)
+        throw new Error("Invalid documentId: " + documentId);
+    const encodedDocumentId = documentId instanceof Uint8Array
+        ? binaryToDocumentId(documentId)
+        : documentId;
+    let url = `${urlPrefix}${encodedDocumentId}`;
+    if (heads !== undefined) {
+        heads.forEach(head => {
+            try {
+                bs58check.decode(head);
+            }
+            catch (e) {
+                throw new Error(`Invalid head: ${head}`);
+            }
+        });
+        url += "#" + heads.join("|");
+    }
+    return url;
+};
+const anyDocumentIdToAutomergeUrl = (id) => isValidAutomergeUrl(id)
+    ? id
+    : isValidDocumentId(id)
+        ? stringifyAutomergeUrl({ documentId: id })
+        : isValidUuid(id)
+            ? parseLegacyUUID(id)
+            : undefined;
+/**
+ * Given a string, returns true if it is a valid Automerge URL. This function also acts as a type
+ * discriminator in Typescript.
+ */
+const isValidAutomergeUrl = (str) => {
+    if (typeof str !== "string" || !str || !str.startsWith(urlPrefix))
+        return false;
     try {
-      Q.decode(w);
-    } catch {
-      throw new Error(`Invalid head: ${w}`);
+        const { documentId, heads } = parseAutomergeUrl(str);
+        if (!isValidDocumentId(documentId))
+            return false;
+        if (heads &&
+            !heads.every(head => {
+                try {
+                    bs58check.decode(head);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }))
+            return false;
+        return true;
+    }
+    catch {
+        return false;
     }
-  }), y += "#" + n.join("|")), y;
-}, rt = (e) => nt(e) ? e : Me(e) ? De({ documentId: e }) : st(e) ? ot(e) : void 0, nt = (e) => {
-  if (typeof e != "string" || !e || !e.startsWith(ee))
-    return !1;
-  try {
-    const { documentId: t, heads: n } = tt(e);
-    return !(!Me(t) || n && !n.every((H) => {
-      try {
-        return Q.decode(H), !0;
-      } catch {
-        return !1;
-      }
-    }));
-  } catch {
-    return !1;
-  }
-}, Me = (e) => typeof e != "string" ? !1 : Re(e) !== void 0, st = (e) => typeof e == "string" && de(e), Re = (e) => Q.decodeUnsafe(e), Ie = (e) => Q.encode(e), ot = (e) => {
-  if (!de(e))
-    return;
-  const t = je(e);
-  return De({ documentId: t });
-}, te = /* @__PURE__ */ new Map();
-function ct(e, { suspense: t } = { suspense: !1 }) {
-  const n = Ve(), H = qe(), [y, w] = X();
-  let a = (
+};
+const isValidDocumentId = (str) => {
+    if (typeof str !== "string")
+        return false;
+    // try to decode from base58
+    const binaryDocumentID = documentIdToBinary(str);
+    return binaryDocumentID !== undefined;
+};
+const isValidUuid = (str) => typeof str === "string" && validate(str);
+const documentIdToBinary = (docId) => bs58check.decodeUnsafe(docId);
+const binaryToDocumentId = (docId) => bs58check.encode(docId);
+const parseLegacyUUID = (str) => {
+    if (!validate(str))
+        return undefined;
+    const documentId = parse(str);
+    return stringifyAutomergeUrl({ documentId });
+};
+
+const wrapperCache = /* @__PURE__ */ new Map();
+function useDocHandle(id, { suspense } = { suspense: false }) {
+  const repo = useRepo();
+  const controllerRef = useRef();
+  const [handle, setHandle] = useState();
+  let currentHandle = (
     // make sure the handle matches the id
-    e && y && y.url === rt(e) ? y : void 0
+    id && handle && handle.url === anyDocumentIdToAutomergeUrl(id) ? handle : void 0
   );
-  if (e && !a) {
-    const s = n.findWithProgress(e);
-    s.state === "ready" && (a = s.handle);
+  if (id && !currentHandle) {
+    const progress = repo.findWithProgress(id);
+    if (progress.state === "ready") {
+      currentHandle = progress.handle;
+    }
   }
-  let c = e ? te.get(e) : void 0;
-  if (!c && e) {
-    H.current?.abort(), H.current = new AbortController();
-    const s = n.find(e, { signal: H.current.signal });
-    c = Ue(s), te.set(e, c);
+  let wrapper = id ? wrapperCache.get(id) : void 0;
+  if (!wrapper && id) {
+    controllerRef.current?.abort();
+    controllerRef.current = new AbortController();
+    const promise = repo.find(id, { signal: controllerRef.current.signal });
+    wrapper = wrapPromise(promise);
+    wrapperCache.set(id, wrapper);
   }
-  return z(() => {
-    a || t || !c || c.promise.then((s) => {
-      w(s);
+  useEffect(() => {
+    if (currentHandle || suspense || !wrapper) {
+      return;
+    }
+    wrapper.promise.then((handle2) => {
+      setHandle(handle2);
     }).catch(() => {
-      w(void 0);
+      setHandle(void 0);
     });
-  }, [a, t, c]), a || !t || !c ? a : c.read();
+  }, [currentHandle, suspense, wrapper]);
+  if (currentHandle || !suspense || !wrapper) {
+    return currentHandle;
+  }
+  return wrapper.read();
 }
-function pt(e, t = { suspense: !1 }) {
-  const n = ct(e, t), [H, y] = X(() => n?.doc()), [w, a] = X();
-  z(() => {
-    y(n?.doc());
-  }, [n]), z(() => {
-    if (!n)
+
+function useDocument(id, params = { suspense: false }) {
+  const handle = useDocHandle(id, params);
+  const [doc, setDoc] = useState(() => handle?.doc());
+  const [deleteError, setDeleteError] = useState();
+  useEffect(() => {
+    setDoc(handle?.doc());
+  }, [handle]);
+  useEffect(() => {
+    if (!handle) {
       return;
-    const s = () => y(n.doc()), o = () => {
-      a(new Error(`Document ${e} was deleted`));
+    }
+    const onChange = () => setDoc(handle.doc());
+    const onDelete = () => {
+      setDeleteError(new Error(`Document ${id} was deleted`));
     };
-    return n.on("change", s), n.on("delete", o), () => {
-      n.removeListener("change", s), n.removeListener("delete", o);
+    handle.on("change", onChange);
+    handle.on("delete", onDelete);
+    return () => {
+      handle.removeListener("change", onChange);
+      handle.removeListener("delete", onDelete);
     };
-  }, [n, e]);
-  const c = Le(
-    (s, o) => {
-      n.change(s, o);
+  }, [handle, id]);
+  const changeDoc = useCallback(
+    (changeFn, options) => {
+      handle.change(changeFn, options);
     },
-    [n]
+    [handle]
   );
-  if (w)
-    throw w;
-  return H ? [H, c] : [void 0, () => {
-  }];
+  if (deleteError) {
+    throw deleteError;
+  }
+  if (!doc) {
+    return [void 0, () => {
+    }];
+  }
+  return [doc, changeDoc];
 }
-function at(e) {
-  const [t, n] = X(() => new Set(e));
-  return z(() => {
-    const H = new Set(e);
-    it(t, H) || n(H);
-  }, [t, e]), t;
+
+function useSet(items) {
+  const [set, setSet] = useState(() => {
+    return new Set(items);
+  });
+  useEffect(() => {
+    const newSet = new Set(items);
+    if (identical(set, newSet)) {
+      return;
+    }
+    setSet(newSet);
+  }, [set, items]);
+  return set;
 }
-function it(e, t) {
-  return e.size === t.size && Array.from(e).every((n) => t.has(n));
+function identical(s1, s2) {
+  return s1.size === s2.size && Array.from(s1).every((v) => s2.has(v));
 }
-function ft(e, { suspense: t = !1 } = {}) {
-  const n = at(e), H = Ve(), [y, w] = X(() => {
-    const s = /* @__PURE__ */ new Map();
-    for (const o of n.values()) {
-      let i;
+
+function useDocHandles(ids, { suspense = false } = {}) {
+  const idSet = useSet(ids);
+  const repo = useRepo();
+  const [handleMap, setHandleMap] = useState(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const id of idSet.values()) {
+      let progress;
       try {
-        i = H.findWithProgress(o);
-      } catch {
+        progress = repo.findWithProgress(id);
+      } catch (e) {
         continue;
       }
-      i.state === "ready" && s.set(o, i.handle);
+      if (progress.state === "ready") {
+        map.set(id, progress.handle);
+      }
     }
-    return s;
-  }), a = [], c = /* @__PURE__ */ new Map();
-  for (const s of n.values()) {
-    let o = y.get(s), i = te.get(s);
-    if (!i)
+    return map;
+  });
+  const pendingPromises = [];
+  const nextHandleMap = /* @__PURE__ */ new Map();
+  for (const id of idSet.values()) {
+    let handle = handleMap.get(id);
+    let wrapper = wrapperCache.get(id);
+    if (!wrapper) {
       try {
-        const h = H.find(s);
-        i = Ue(h), te.set(s, i);
-      } catch {
+        const promise = repo.find(id);
+        wrapper = wrapPromise(promise);
+        wrapperCache.set(id, wrapper);
+      } catch (e) {
         continue;
       }
+    }
     try {
-      o ??= i.read(), c.set(s, o);
-    } catch (h) {
-      h instanceof Promise ? a.push(i) : c.set(s, void 0);
+      handle ??= wrapper.read();
+      nextHandleMap.set(id, handle);
+    } catch (e) {
+      if (e instanceof Promise) {
+        pendingPromises.push(wrapper);
+      } else {
+        nextHandleMap.set(id, void 0);
+      }
     }
   }
-  if (z(() => {
-    a.length > 0 ? Promise.allSettled(a.map((s) => s.promise)).then(
-      (s) => {
-        s.forEach((o) => {
-          if (o.status === "fulfilled") {
-            const i = o.value;
-            c.set(i.url, i);
-          }
-        }), w(c);
-      }
-    ) : w(c);
-  }, [t, n]), t && a.length > 0)
-    throw Promise.all(a.map((s) => s.promise));
-  return y;
+  useEffect(() => {
+    if (pendingPromises.length > 0) {
+      void Promise.allSettled(pendingPromises.map((p) => p.promise)).then(
+        (handles) => {
+          handles.forEach((r) => {
+            if (r.status === "fulfilled") {
+              const h = r.value;
+              nextHandleMap.set(h.url, h);
+            }
+          });
+          setHandleMap(nextHandleMap);
+        }
+      );
+    } else {
+      setHandleMap(nextHandleMap);
+    }
+  }, [suspense, idSet]);
+  if (suspense && pendingPromises.length > 0) {
+    throw Promise.all(pendingPromises.map((p) => p.promise));
+  }
+  return handleMap;
 }
-function Ht(e, { suspense: t = !0 } = {}) {
-  const n = ft(e, { suspense: t }), [H, y] = X(() => {
-    const a = /* @__PURE__ */ new Map();
-    return n.forEach((c) => {
-      const s = c?.url;
-      s && a.set(s, c?.doc());
-    }), a;
+
+function useDocuments(ids, { suspense = true } = {}) {
+  const handleMap = useDocHandles(ids, { suspense });
+  const [docMap, setDocMap] = useState(() => {
+    const docs = /* @__PURE__ */ new Map();
+    handleMap.forEach((handle) => {
+      const url = handle?.url;
+      if (url) {
+        docs.set(url, handle?.doc());
+      }
+    });
+    return docs;
   });
-  z(() => {
-    const a = /* @__PURE__ */ new Map();
-    return n.forEach((c, s) => {
-      if (c) {
-        const o = () => {
-          y((i) => {
-            const h = new Map(i);
-            return h.set(s, c.doc()), h;
+  useEffect(() => {
+    const listeners = /* @__PURE__ */ new Map();
+    handleMap.forEach((handle, id) => {
+      if (handle) {
+        const onChange = () => {
+          setDocMap((prev) => {
+            const next = new Map(prev);
+            next.set(id, handle.doc());
+            return next;
           });
         };
-        y((i) => {
-          const h = new Map(i);
-          return h.set(s, c.doc()), h;
-        }), c.on("change", o), a.set(s, o);
+        setDocMap((prev) => {
+          const next = new Map(prev);
+          next.set(id, handle.doc());
+          return next;
+        });
+        handle.on("change", onChange);
+        listeners.set(id, onChange);
+      }
+    });
+    setDocMap((prev) => {
+      const next = new Map(prev);
+      for (const [id] of next) {
+        if (!handleMap.has(id)) {
+          next.delete(id);
+        }
       }
-    }), y((c) => {
-      const s = new Map(c);
-      for (const [o] of s)
-        n.has(o) || s.delete(o);
-      return s;
-    }), () => {
-      n.forEach((c, s) => {
-        const o = a.get(s);
-        c && o && c.removeListener("change", o);
+      return next;
+    });
+    return () => {
+      handleMap.forEach((handle, id) => {
+        const listener = listeners.get(id);
+        if (handle && listener) {
+          handle.removeListener("change", listener);
+        }
       });
     };
-  }, [n]);
-  const w = Le(
-    (a, c, s) => {
-      const o = n.get(a);
-      o && o.change(c, s);
+  }, [handleMap]);
+  const changeDoc = useCallback(
+    (id, changeFn, options) => {
+      const handle = handleMap.get(id);
+      if (handle) {
+        handle.change(changeFn, options);
+      }
     },
-    [n]
+    [handleMap]
   );
-  return [H, w];
+  return [docMap, changeDoc];
 }
-var fe, Ee;
-function ht() {
-  if (Ee) return fe;
-  Ee = 1;
-  var e = ke, t = function(H) {
-    return typeof H == "function";
-  }, n = function(H) {
-    var y = e.useState(H), w = y[0], a = y[1], c = e.useRef(w), s = e.useCallback(function(o) {
-      c.current = t(o) ? o(c.current) : o, a(c.current);
-    }, []);
-    return [w, s, c];
-  };
-  return fe = n, fe;
+
+var dist;
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	var react_1 = require$$0;
+	var isFunction = function (setStateAction) {
+	    return typeof setStateAction === "function";
+	};
+	var useStateRef = function (initialState) {
+	    var _a = react_1.useState(initialState), state = _a[0], setState = _a[1];
+	    var ref = react_1.useRef(state);
+	    var dispatch = react_1.useCallback(function (setStateAction) {
+	        ref.current = isFunction(setStateAction) ? setStateAction(ref.current) : setStateAction;
+	        setState(ref.current);
+	    }, []);
+	    return [state, dispatch, ref];
+	};
+	dist = useStateRef;
+	return dist;
 }
-var ut = ht();
-const ue = /* @__PURE__ */ be(ut);
-var he = { exports: {} }, Be;
-function lt() {
-  return Be || (Be = 1, function(e) {
-    var t = Object.prototype.hasOwnProperty, n = "~";
-    function H() {
-    }
-    Object.create && (H.prototype = /* @__PURE__ */ Object.create(null), new H().__proto__ || (n = !1));
-    function y(s, o, i) {
-      this.fn = s, this.context = o, this.once = i || !1;
-    }
-    function w(s, o, i, h, m) {
-      if (typeof i != "function")
-        throw new TypeError("The listener must be a function");
-      var B = new y(i, h || s, m), f = n ? n + o : o;
-      return s._events[f] ? s._events[f].fn ? s._events[f] = [s._events[f], B] : s._events[f].push(B) : (s._events[f] = B, s._eventsCount++), s;
-    }
-    function a(s, o) {
-      --s._eventsCount === 0 ? s._events = new H() : delete s._events[o];
-    }
-    function c() {
-      this._events = new H(), this._eventsCount = 0;
+
+var distExports = requireDist();
+const useStateRef = /*@__PURE__*/getDefaultExportFromCjs(distExports);
+
+var eventemitter3 = {exports: {}};
+
+var hasRequiredEventemitter3;
+
+function requireEventemitter3 () {
+	if (hasRequiredEventemitter3) return eventemitter3.exports;
+	hasRequiredEventemitter3 = 1;
+	(function (module) {
+
+		var has = Object.prototype.hasOwnProperty
+		  , prefix = '~';
+
+		/**
+		 * Constructor to create a storage for our `EE` objects.
+		 * An `Events` instance is a plain object whose properties are event names.
+		 *
+		 * @constructor
+		 * @private
+		 */
+		function Events() {}
+
+		//
+		// We try to not inherit from `Object.prototype`. In some engines creating an
+		// instance in this way is faster than calling `Object.create(null)` directly.
+		// If `Object.create(null)` is not supported we prefix the event names with a
+		// character to make sure that the built-in object properties are not
+		// overridden or used as an attack vector.
+		//
+		if (Object.create) {
+		  Events.prototype = Object.create(null);
+
+		  //
+		  // This hack is needed because the `__proto__` property is still inherited in
+		  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+		  //
+		  if (!new Events().__proto__) prefix = false;
+		}
+
+		/**
+		 * Representation of a single event listener.
+		 *
+		 * @param {Function} fn The listener function.
+		 * @param {*} context The context to invoke the listener with.
+		 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+		 * @constructor
+		 * @private
+		 */
+		function EE(fn, context, once) {
+		  this.fn = fn;
+		  this.context = context;
+		  this.once = once || false;
+		}
+
+		/**
+		 * Add a listener for a given event.
+		 *
+		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} context The context to invoke the listener with.
+		 * @param {Boolean} once Specify if the listener is a one-time listener.
+		 * @returns {EventEmitter}
+		 * @private
+		 */
+		function addListener(emitter, event, fn, context, once) {
+		  if (typeof fn !== 'function') {
+		    throw new TypeError('The listener must be a function');
+		  }
+
+		  var listener = new EE(fn, context || emitter, once)
+		    , evt = prefix ? prefix + event : event;
+
+		  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+		  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+		  else emitter._events[evt] = [emitter._events[evt], listener];
+
+		  return emitter;
+		}
+
+		/**
+		 * Clear event by name.
+		 *
+		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+		 * @param {(String|Symbol)} evt The Event name.
+		 * @private
+		 */
+		function clearEvent(emitter, evt) {
+		  if (--emitter._eventsCount === 0) emitter._events = new Events();
+		  else delete emitter._events[evt];
+		}
+
+		/**
+		 * Minimal `EventEmitter` interface that is molded against the Node.js
+		 * `EventEmitter` interface.
+		 *
+		 * @constructor
+		 * @public
+		 */
+		function EventEmitter() {
+		  this._events = new Events();
+		  this._eventsCount = 0;
+		}
+
+		/**
+		 * Return an array listing the events for which the emitter has registered
+		 * listeners.
+		 *
+		 * @returns {Array}
+		 * @public
+		 */
+		EventEmitter.prototype.eventNames = function eventNames() {
+		  var names = []
+		    , events
+		    , name;
+
+		  if (this._eventsCount === 0) return names;
+
+		  for (name in (events = this._events)) {
+		    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+		  }
+
+		  if (Object.getOwnPropertySymbols) {
+		    return names.concat(Object.getOwnPropertySymbols(events));
+		  }
+
+		  return names;
+		};
+
+		/**
+		 * Return the listeners registered for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Array} The registered listeners.
+		 * @public
+		 */
+		EventEmitter.prototype.listeners = function listeners(event) {
+		  var evt = prefix ? prefix + event : event
+		    , handlers = this._events[evt];
+
+		  if (!handlers) return [];
+		  if (handlers.fn) return [handlers.fn];
+
+		  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+		    ee[i] = handlers[i].fn;
+		  }
+
+		  return ee;
+		};
+
+		/**
+		 * Return the number of listeners listening to a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Number} The number of listeners.
+		 * @public
+		 */
+		EventEmitter.prototype.listenerCount = function listenerCount(event) {
+		  var evt = prefix ? prefix + event : event
+		    , listeners = this._events[evt];
+
+		  if (!listeners) return 0;
+		  if (listeners.fn) return 1;
+		  return listeners.length;
+		};
+
+		/**
+		 * Calls each of the listeners registered for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Boolean} `true` if the event had listeners, else `false`.
+		 * @public
+		 */
+		EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+		  var evt = prefix ? prefix + event : event;
+
+		  if (!this._events[evt]) return false;
+
+		  var listeners = this._events[evt]
+		    , len = arguments.length
+		    , args
+		    , i;
+
+		  if (listeners.fn) {
+		    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+		    switch (len) {
+		      case 1: return listeners.fn.call(listeners.context), true;
+		      case 2: return listeners.fn.call(listeners.context, a1), true;
+		      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+		      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+		      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+		      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+		    }
+
+		    for (i = 1, args = new Array(len -1); i < len; i++) {
+		      args[i - 1] = arguments[i];
+		    }
+
+		    listeners.fn.apply(listeners.context, args);
+		  } else {
+		    var length = listeners.length
+		      , j;
+
+		    for (i = 0; i < length; i++) {
+		      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+		      switch (len) {
+		        case 1: listeners[i].fn.call(listeners[i].context); break;
+		        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+		        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+		        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+		        default:
+		          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+		            args[j - 1] = arguments[j];
+		          }
+
+		          listeners[i].fn.apply(listeners[i].context, args);
+		      }
+		    }
+		  }
+
+		  return true;
+		};
+
+		/**
+		 * Add a listener for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} [context=this] The context to invoke the listener with.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.on = function on(event, fn, context) {
+		  return addListener(this, event, fn, context, false);
+		};
+
+		/**
+		 * Add a one-time listener for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} [context=this] The context to invoke the listener with.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.once = function once(event, fn, context) {
+		  return addListener(this, event, fn, context, true);
+		};
+
+		/**
+		 * Remove the listeners of a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn Only remove the listeners that match this function.
+		 * @param {*} context Only remove the listeners that have this context.
+		 * @param {Boolean} once Only remove one-time listeners.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+		  var evt = prefix ? prefix + event : event;
+
+		  if (!this._events[evt]) return this;
+		  if (!fn) {
+		    clearEvent(this, evt);
+		    return this;
+		  }
+
+		  var listeners = this._events[evt];
+
+		  if (listeners.fn) {
+		    if (
+		      listeners.fn === fn &&
+		      (!once || listeners.once) &&
+		      (!context || listeners.context === context)
+		    ) {
+		      clearEvent(this, evt);
+		    }
+		  } else {
+		    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+		      if (
+		        listeners[i].fn !== fn ||
+		        (once && !listeners[i].once) ||
+		        (context && listeners[i].context !== context)
+		      ) {
+		        events.push(listeners[i]);
+		      }
+		    }
+
+		    //
+		    // Reset the array, or remove it completely if we have no more listeners.
+		    //
+		    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+		    else clearEvent(this, evt);
+		  }
+
+		  return this;
+		};
+
+		/**
+		 * Remove all listeners, or those of the specified event.
+		 *
+		 * @param {(String|Symbol)} [event] The event name.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+		  var evt;
+
+		  if (event) {
+		    evt = prefix ? prefix + event : event;
+		    if (this._events[evt]) clearEvent(this, evt);
+		  } else {
+		    this._events = new Events();
+		    this._eventsCount = 0;
+		  }
+
+		  return this;
+		};
+
+		//
+		// Alias methods names because people roll like that.
+		//
+		EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+		EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+		//
+		// Expose the prefix.
+		//
+		EventEmitter.prefixed = prefix;
+
+		//
+		// Allow `EventEmitter` to be imported as module namespace.
+		//
+		EventEmitter.EventEmitter = EventEmitter;
+
+		//
+		// Expose the module.
+		//
+		{
+		  module.exports = EventEmitter;
+		} 
+	} (eventemitter3));
+	return eventemitter3.exports;
+}
+
+var eventemitter3Exports = requireEventemitter3();
+const EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
+
+const peerEvents = new EventEmitter();
+const useRemoteAwareness = ({
+  handle,
+  localUserId,
+  offlineTimeout = 3e4,
+  getTime = () => (/* @__PURE__ */ new Date()).getTime()
+}) => {
+  const [peerStates, setPeerStates, peerStatesRef] = useStateRef({});
+  const [heartbeats, setHeartbeats, heartbeatsRef] = useStateRef({});
+  useEffect(() => {
+    if (!handle) {
+      return;
     }
-    c.prototype.eventNames = function() {
-      var o = [], i, h;
-      if (this._eventsCount === 0) return o;
-      for (h in i = this._events)
-        t.call(i, h) && o.push(n ? h.slice(1) : h);
-      return Object.getOwnPropertySymbols ? o.concat(Object.getOwnPropertySymbols(i)) : o;
-    }, c.prototype.listeners = function(o) {
-      var i = n ? n + o : o, h = this._events[i];
-      if (!h) return [];
-      if (h.fn) return [h.fn];
-      for (var m = 0, B = h.length, f = new Array(B); m < B; m++)
-        f[m] = h[m].fn;
-      return f;
-    }, c.prototype.listenerCount = function(o) {
-      var i = n ? n + o : o, h = this._events[i];
-      return h ? h.fn ? 1 : h.length : 0;
-    }, c.prototype.emit = function(o, i, h, m, B, f) {
-      var g = n ? n + o : o;
-      if (!this._events[g]) return !1;
-      var d = this._events[g], V = arguments.length, M, x;
-      if (d.fn) {
-        switch (d.once && this.removeListener(o, d.fn, void 0, !0), V) {
-          case 1:
-            return d.fn.call(d.context), !0;
-          case 2:
-            return d.fn.call(d.context, i), !0;
-          case 3:
-            return d.fn.call(d.context, i, h), !0;
-          case 4:
-            return d.fn.call(d.context, i, h, m), !0;
-          case 5:
-            return d.fn.call(d.context, i, h, m, B), !0;
-          case 6:
-            return d.fn.call(d.context, i, h, m, B, f), !0;
+    const handleIncomingUpdate = (event) => {
+      const [userId, state] = event.message;
+      if (userId === localUserId) return;
+      if (!heartbeatsRef.current[userId]) peerEvents.emit("new_peer", event);
+      setPeerStates({
+        ...peerStatesRef.current,
+        [userId]: state
+      });
+      setHeartbeats({
+        ...heartbeatsRef.current,
+        [userId]: getTime()
+      });
+    };
+    const pruneOfflinePeers = () => {
+      const peerStates2 = { ...peerStatesRef.current };
+      const heartbeats2 = { ...heartbeatsRef.current };
+      const time = getTime();
+      let hasChanges = false;
+      for (const key in heartbeats2) {
+        if (time - heartbeats2[key] > offlineTimeout) {
+          delete peerStates2[key];
+          delete heartbeats2[key];
+          hasChanges = true;
         }
-        for (x = 1, M = new Array(V - 1); x < V; x++)
-          M[x - 1] = arguments[x];
-        d.fn.apply(d.context, M);
-      } else {
-        var R = d.length, A;
-        for (x = 0; x < R; x++)
-          switch (d[x].once && this.removeListener(o, d[x].fn, void 0, !0), V) {
-            case 1:
-              d[x].fn.call(d[x].context);
-              break;
-            case 2:
-              d[x].fn.call(d[x].context, i);
-              break;
-            case 3:
-              d[x].fn.call(d[x].context, i, h);
-              break;
-            case 4:
-              d[x].fn.call(d[x].context, i, h, m);
-              break;
-            default:
-              if (!M) for (A = 1, M = new Array(V - 1); A < V; A++)
-                M[A - 1] = arguments[A];
-              d[x].fn.apply(d[x].context, M);
-          }
       }
-      return !0;
-    }, c.prototype.on = function(o, i, h) {
-      return w(this, o, i, h, !1);
-    }, c.prototype.once = function(o, i, h) {
-      return w(this, o, i, h, !0);
-    }, c.prototype.removeListener = function(o, i, h, m) {
-      var B = n ? n + o : o;
-      if (!this._events[B]) return this;
-      if (!i)
-        return a(this, B), this;
-      var f = this._events[B];
-      if (f.fn)
-        f.fn === i && (!m || f.once) && (!h || f.context === h) && a(this, B);
-      else {
-        for (var g = 0, d = [], V = f.length; g < V; g++)
-          (f[g].fn !== i || m && !f[g].once || h && f[g].context !== h) && d.push(f[g]);
-        d.length ? this._events[B] = d.length === 1 ? d[0] : d : a(this, B);
+      if (hasChanges) {
+        setPeerStates(peerStates2);
+        setHeartbeats(heartbeats2);
       }
-      return this;
-    }, c.prototype.removeAllListeners = function(o) {
-      var i;
-      return o ? (i = n ? n + o : o, this._events[i] && a(this, i)) : (this._events = new H(), this._eventsCount = 0), this;
-    }, c.prototype.off = c.prototype.removeListener, c.prototype.addListener = c.prototype.on, c.prefixed = n, c.EventEmitter = c, e.exports = c;
-  }(he)), he.exports;
-}
-var dt = lt();
-const bt = /* @__PURE__ */ be(dt), le = new bt(), yt = ({
-  handle: e,
-  localUserId: t,
-  offlineTimeout: n = 3e4,
-  getTime: H = () => (/* @__PURE__ */ new Date()).getTime()
-}) => {
-  const [y, w, a] = ue({}), [c, s, o] = ue({});
-  return z(() => {
-    if (!e)
-      return;
-    const i = (B) => {
-      const [f, g] = B.message;
-      f !== t && (o.current[f] || le.emit("new_peer", B), w({
-        ...a.current,
-        [f]: g
-      }), s({
-        ...o.current,
-        [f]: H()
-      }));
-    }, h = () => {
-      const B = { ...a.current }, f = { ...o.current }, g = H();
-      let d = !1;
-      for (const V in f)
-        g - f[V] > n && (delete B[V], delete f[V], d = !0);
-      d && (w(B), s(f));
     };
-    e.on("ephemeral-message", i);
-    const m = setInterval(
-      h,
-      n
+    handle.on("ephemeral-message", handleIncomingUpdate);
+    const pruneOfflinePeersIntervalId = setInterval(
+      pruneOfflinePeers,
+      offlineTimeout
     );
     return () => {
-      e.removeListener("ephemeral-message", i), clearInterval(m);
+      handle.removeListener("ephemeral-message", handleIncomingUpdate);
+      clearInterval(pruneOfflinePeersIntervalId);
     };
-  }, [e, t, n, H]), [y, c];
-}, At = ({
-  handle: e,
-  userId: t,
-  initialState: n,
-  heartbeatTime: H = 15e3
+  }, [handle, localUserId, offlineTimeout, getTime]);
+  return [peerStates, heartbeats];
+};
+
+const useLocalAwareness = ({
+  handle,
+  userId,
+  initialState,
+  heartbeatTime = 15e3
 }) => {
-  const [y, w, a] = ue(n), c = (s) => {
-    const o = typeof s == "function" ? s(a.current) : s;
-    w(o), e && e.broadcast([t, o]);
+  const [localState, setLocalState, localStateRef] = useStateRef(initialState);
+  const setState = (stateOrUpdater) => {
+    const state = typeof stateOrUpdater === "function" ? stateOrUpdater(localStateRef.current) : stateOrUpdater;
+    setLocalState(state);
+    if (handle) {
+      handle.broadcast([userId, state]);
+    }
   };
-  return z(() => {
-    if (!t || !e)
+  useEffect(() => {
+    if (!userId || !handle) {
       return;
-    const s = () => void e.broadcast([t, a.current]);
-    s();
-    const o = setInterval(s, H);
-    return () => void clearInterval(o);
-  }, [e, t, H]), z(() => {
-    if (!e || !t)
+    }
+    const heartbeat = () => void handle.broadcast([userId, localStateRef.current]);
+    heartbeat();
+    const heartbeatIntervalId = setInterval(heartbeat, heartbeatTime);
+    return () => void clearInterval(heartbeatIntervalId);
+  }, [handle, userId, heartbeatTime]);
+  useEffect(() => {
+    if (!handle || !userId) {
       return;
-    let s;
-    const o = le.on("new_peer", () => {
-      s = setTimeout(
-        () => e.broadcast([t, a.current]),
+    }
+    let broadcastTimeoutId;
+    const newPeerEvents = peerEvents.on("new_peer", () => {
+      broadcastTimeoutId = setTimeout(
+        () => handle.broadcast([userId, localStateRef.current]),
         500
         // Wait for the peer to be ready
       );
     });
     return () => {
-      o.off("new_peer"), s && clearTimeout(s);
+      newPeerEvents.off("new_peer");
+      broadcastTimeoutId && clearTimeout(broadcastTimeoutId);
     };
-  }, [e, t, le]), [y, c];
-};
-export {
-  Ge as RepoContext,
-  ct as useDocHandle,
-  ft as useDocHandles,
-  pt as useDocument,
-  Ht as useDocuments,
-  At as useLocalAwareness,
-  yt as useRemoteAwareness,
-  Ve as useRepo
+  }, [handle, userId, peerEvents]);
+  return [localState, setState];
 };
+
+export { RepoContext, useDocHandle, useDocHandles, useDocument, useDocuments, useLocalAwareness, useRemoteAwareness, useRepo };
+//# sourceMappingURL=index.js.map