@fingerprint79/react-native 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3717 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx } from "react/jsx-runtime";
+import { useMemo, useState, useEffect, createContext, useContext, useCallback } from "react";
+import { Dimensions, PixelRatio, Platform, NativeModules, I18nManager } from "react-native";
+let decoder;
+try {
+  decoder = new TextDecoder();
+} catch (error) {
+}
+let src;
+let srcEnd;
+let position$1 = 0;
+const LEGACY_RECORD_INLINE_ID = 105;
+const RECORD_DEFINITIONS_ID = 57342;
+const RECORD_INLINE_ID = 57343;
+const BUNDLED_STRINGS_ID = 57337;
+const PACKED_REFERENCE_TAG_ID = 6;
+const STOP_CODE = {};
+let maxArraySize = 11281e4;
+let maxMapSize = 1681e4;
+let currentDecoder = {};
+let currentStructures;
+let srcString;
+let srcStringStart = 0;
+let srcStringEnd = 0;
+let bundledStrings$1;
+let referenceMap;
+let currentExtensions = [];
+let currentExtensionRanges = [];
+let packedValues;
+let dataView;
+let restoreMapsAsObject;
+let defaultOptions = {
+  useRecords: false,
+  mapsAsObjects: true
+};
+let sequentialMode = false;
+let inlineObjectReadThreshold = 2;
+try {
+  new Function("");
+} catch (error) {
+  inlineObjectReadThreshold = Infinity;
+}
+class Decoder {
+  constructor(options) {
+    if (options) {
+      if ((options.keyMap || options._keyMap) && !options.useRecords) {
+        options.useRecords = false;
+        options.mapsAsObjects = true;
+      }
+      if (options.useRecords === false && options.mapsAsObjects === void 0)
+        options.mapsAsObjects = true;
+      if (options.getStructures)
+        options.getShared = options.getStructures;
+      if (options.getShared && !options.structures)
+        (options.structures = []).uninitialized = true;
+      if (options.keyMap) {
+        this.mapKey = /* @__PURE__ */ new Map();
+        for (let [k, v] of Object.entries(options.keyMap)) this.mapKey.set(v, k);
+      }
+    }
+    Object.assign(this, options);
+  }
+  /*
+  decodeKey(key) {
+  	return this.keyMap
+  		? Object.keys(this.keyMap)[Object.values(this.keyMap).indexOf(key)] || key
+  		: key
+  }
+  */
+  decodeKey(key) {
+    return this.keyMap ? this.mapKey.get(key) || key : key;
+  }
+  encodeKey(key) {
+    return this.keyMap && this.keyMap.hasOwnProperty(key) ? this.keyMap[key] : key;
+  }
+  encodeKeys(rec) {
+    if (!this._keyMap) return rec;
+    let map = /* @__PURE__ */ new Map();
+    for (let [k, v] of Object.entries(rec)) map.set(this._keyMap.hasOwnProperty(k) ? this._keyMap[k] : k, v);
+    return map;
+  }
+  decodeKeys(map) {
+    if (!this._keyMap || map.constructor.name != "Map") return map;
+    if (!this._mapKey) {
+      this._mapKey = /* @__PURE__ */ new Map();
+      for (let [k, v] of Object.entries(this._keyMap)) this._mapKey.set(v, k);
+    }
+    let res = {};
+    map.forEach((v, k) => res[safeKey(this._mapKey.has(k) ? this._mapKey.get(k) : k)] = v);
+    return res;
+  }
+  mapDecode(source, end) {
+    let res = this.decode(source);
+    if (this._keyMap) {
+      switch (res.constructor.name) {
+        case "Array":
+          return res.map((r) => this.decodeKeys(r));
+      }
+    }
+    return res;
+  }
+  decode(source, end) {
+    if (src) {
+      return saveState(() => {
+        clearSource();
+        return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end);
+      });
+    }
+    srcEnd = end > -1 ? end : source.length;
+    position$1 = 0;
+    srcStringEnd = 0;
+    srcString = null;
+    bundledStrings$1 = null;
+    src = source;
+    try {
+      dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
+    } catch (error) {
+      src = null;
+      if (source instanceof Uint8Array)
+        throw error;
+      throw new Error("Source must be a Uint8Array or Buffer but was a " + (source && typeof source == "object" ? source.constructor.name : typeof source));
+    }
+    if (this instanceof Decoder) {
+      currentDecoder = this;
+      packedValues = this.sharedValues && (this.pack ? new Array(this.maxPrivatePackedValues || 16).concat(this.sharedValues) : this.sharedValues);
+      if (this.structures) {
+        currentStructures = this.structures;
+        return checkedRead();
+      } else if (!currentStructures || currentStructures.length > 0) {
+        currentStructures = [];
+      }
+    } else {
+      currentDecoder = defaultOptions;
+      if (!currentStructures || currentStructures.length > 0)
+        currentStructures = [];
+      packedValues = null;
+    }
+    return checkedRead();
+  }
+  decodeMultiple(source, forEach) {
+    let values, lastPosition = 0;
+    try {
+      let size = source.length;
+      sequentialMode = true;
+      let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
+      if (forEach) {
+        if (forEach(value) === false) {
+          return;
+        }
+        while (position$1 < size) {
+          lastPosition = position$1;
+          if (forEach(checkedRead()) === false) {
+            return;
+          }
+        }
+      } else {
+        values = [value];
+        while (position$1 < size) {
+          lastPosition = position$1;
+          values.push(checkedRead());
+        }
+        return values;
+      }
+    } catch (error) {
+      error.lastPosition = lastPosition;
+      error.values = values;
+      throw error;
+    } finally {
+      sequentialMode = false;
+      clearSource();
+    }
+  }
+}
+function checkedRead() {
+  try {
+    let result = read();
+    if (bundledStrings$1) {
+      if (position$1 >= bundledStrings$1.postBundlePosition) {
+        let error = new Error("Unexpected bundle position");
+        error.incomplete = true;
+        throw error;
+      }
+      position$1 = bundledStrings$1.postBundlePosition;
+      bundledStrings$1 = null;
+    }
+    if (position$1 == srcEnd) {
+      currentStructures = null;
+      src = null;
+      if (referenceMap)
+        referenceMap = null;
+    } else if (position$1 > srcEnd) {
+      let error = new Error("Unexpected end of CBOR data");
+      error.incomplete = true;
+      throw error;
+    } else if (!sequentialMode) {
+      throw new Error("Data read, but end of buffer not reached");
+    }
+    return result;
+  } catch (error) {
+    clearSource();
+    if (error instanceof RangeError || error.message.startsWith("Unexpected end of buffer")) {
+      error.incomplete = true;
+    }
+    throw error;
+  }
+}
+function read() {
+  let token = src[position$1++];
+  let majorType = token >> 5;
+  token = token & 31;
+  if (token > 23) {
+    switch (token) {
+      case 24:
+        token = src[position$1++];
+        break;
+      case 25:
+        if (majorType == 7) {
+          return getFloat16();
+        }
+        token = dataView.getUint16(position$1);
+        position$1 += 2;
+        break;
+      case 26:
+        if (majorType == 7) {
+          let value = dataView.getFloat32(position$1);
+          if (currentDecoder.useFloat32 > 2) {
+            let multiplier = mult10[(src[position$1] & 127) << 1 | src[position$1 + 1] >> 7];
+            position$1 += 4;
+            return (multiplier * value + (value > 0 ? 0.5 : -0.5) >> 0) / multiplier;
+          }
+          position$1 += 4;
+          return value;
+        }
+        token = dataView.getUint32(position$1);
+        position$1 += 4;
+        if (majorType === 1) return -1 - token;
+        break;
+      case 27:
+        if (majorType == 7) {
+          let value = dataView.getFloat64(position$1);
+          position$1 += 8;
+          return value;
+        }
+        if (majorType > 1) {
+          if (dataView.getUint32(position$1) > 0)
+            throw new Error("JavaScript does not support arrays, maps, or strings with length over 4294967295");
+          token = dataView.getUint32(position$1 + 4);
+        } else if (currentDecoder.int64AsNumber) {
+          token = dataView.getUint32(position$1) * 4294967296;
+          token += dataView.getUint32(position$1 + 4);
+        } else token = dataView.getBigUint64(position$1);
+        position$1 += 8;
+        break;
+      case 31:
+        switch (majorType) {
+          case 2:
+          case 3:
+            throw new Error("Indefinite length not supported for byte or text strings");
+          case 4:
+            let array = [];
+            let value, i = 0;
+            while ((value = read()) != STOP_CODE) {
+              if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`);
+              array[i++] = value;
+            }
+            return majorType == 4 ? array : majorType == 3 ? array.join("") : Buffer.concat(array);
+          case 5:
+            let key;
+            if (currentDecoder.mapsAsObjects) {
+              let object = {};
+              let i2 = 0;
+              if (currentDecoder.keyMap) {
+                while ((key = read()) != STOP_CODE) {
+                  if (i2++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`);
+                  object[safeKey(currentDecoder.decodeKey(key))] = read();
+                }
+              } else {
+                while ((key = read()) != STOP_CODE) {
+                  if (i2++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`);
+                  object[safeKey(key)] = read();
+                }
+              }
+              return object;
+            } else {
+              if (restoreMapsAsObject) {
+                currentDecoder.mapsAsObjects = true;
+                restoreMapsAsObject = false;
+              }
+              let map = /* @__PURE__ */ new Map();
+              if (currentDecoder.keyMap) {
+                let i2 = 0;
+                while ((key = read()) != STOP_CODE) {
+                  if (i2++ >= maxMapSize) {
+                    throw new Error(`Map size exceeds ${maxMapSize}`);
+                  }
+                  map.set(currentDecoder.decodeKey(key), read());
+                }
+              } else {
+                let i2 = 0;
+                while ((key = read()) != STOP_CODE) {
+                  if (i2++ >= maxMapSize) {
+                    throw new Error(`Map size exceeds ${maxMapSize}`);
+                  }
+                  map.set(key, read());
+                }
+              }
+              return map;
+            }
+          case 7:
+            return STOP_CODE;
+          default:
+            throw new Error("Invalid major type for indefinite length " + majorType);
+        }
+      default:
+        throw new Error("Unknown token " + token);
+    }
+  }
+  switch (majorType) {
+    case 0:
+      return token;
+    case 1:
+      return ~token;
+    case 2:
+      return readBin(token);
+    case 3:
+      if (srcStringEnd >= position$1) {
+        return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart);
+      }
+      if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
+        let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
+        if (string != null)
+          return string;
+      }
+      return readFixedString(token);
+    case 4:
+      if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`);
+      let array = new Array(token);
+      for (let i = 0; i < token; i++) array[i] = read();
+      return array;
+    case 5:
+      if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`);
+      if (currentDecoder.mapsAsObjects) {
+        let object = {};
+        if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
+        else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
+        return object;
+      } else {
+        if (restoreMapsAsObject) {
+          currentDecoder.mapsAsObjects = true;
+          restoreMapsAsObject = false;
+        }
+        let map = /* @__PURE__ */ new Map();
+        if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()), read());
+        else for (let i = 0; i < token; i++) map.set(read(), read());
+        return map;
+      }
+    case 6:
+      if (token >= BUNDLED_STRINGS_ID) {
+        let structure = currentStructures[token & 8191];
+        if (structure) {
+          if (!structure.read) structure.read = createStructureReader(structure);
+          return structure.read();
+        }
+        if (token < 65536) {
+          if (token == RECORD_INLINE_ID) {
+            let length = readJustLength();
+            let id = read();
+            let structure2 = read();
+            recordDefinition(id, structure2);
+            let object = {};
+            if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
+              let key = currentDecoder.decodeKey(structure2[i - 2]);
+              object[safeKey(key)] = read();
+            }
+            else for (let i = 2; i < length; i++) {
+              let key = structure2[i - 2];
+              object[safeKey(key)] = read();
+            }
+            return object;
+          } else if (token == RECORD_DEFINITIONS_ID) {
+            let length = readJustLength();
+            let id = read();
+            for (let i = 2; i < length; i++) {
+              recordDefinition(id++, read());
+            }
+            return read();
+          } else if (token == BUNDLED_STRINGS_ID) {
+            return readBundleExt();
+          }
+          if (currentDecoder.getShared) {
+            loadShared();
+            structure = currentStructures[token & 8191];
+            if (structure) {
+              if (!structure.read)
+                structure.read = createStructureReader(structure);
+              return structure.read();
+            }
+          }
+        }
+      }
+      let extension = currentExtensions[token];
+      if (extension) {
+        if (extension.handlesRead)
+          return extension(read);
+        else
+          return extension(read());
+      } else {
+        let input = read();
+        for (let i = 0; i < currentExtensionRanges.length; i++) {
+          let value = currentExtensionRanges[i](token, input);
+          if (value !== void 0)
+            return value;
+        }
+        return new Tag(input, token);
+      }
+    case 7:
+      switch (token) {
+        case 20:
+          return false;
+        case 21:
+          return true;
+        case 22:
+          return null;
+        case 23:
+          return;
+        case 31:
+        default:
+          let packedValue = (packedValues || getPackedValues())[token];
+          if (packedValue !== void 0)
+            return packedValue;
+          throw new Error("Unknown token " + token);
+      }
+    default:
+      if (isNaN(token)) {
+        let error = new Error("Unexpected end of CBOR data");
+        error.incomplete = true;
+        throw error;
+      }
+      throw new Error("Unknown CBOR token " + token);
+  }
+}
+const validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
+function createStructureReader(structure) {
+  if (!structure) throw new Error("Structure is required in record definition");
+  function readObject() {
+    let length = src[position$1++];
+    length = length & 31;
+    if (length > 23) {
+      switch (length) {
+        case 24:
+          length = src[position$1++];
+          break;
+        case 25:
+          length = dataView.getUint16(position$1);
+          position$1 += 2;
+          break;
+        case 26:
+          length = dataView.getUint32(position$1);
+          position$1 += 4;
+          break;
+        default:
+          throw new Error("Expected array header, but got " + src[position$1 - 1]);
+      }
+    }
+    let compiledReader = this.compiledReader;
+    while (compiledReader) {
+      if (compiledReader.propertyCount === length)
+        return compiledReader(read);
+      compiledReader = compiledReader.next;
+    }
+    if (this.slowReads++ >= inlineObjectReadThreshold) {
+      let array = this.length == length ? this : this.slice(0, length);
+      compiledReader = currentDecoder.keyMap ? new Function("r", "return {" + array.map((k) => currentDecoder.decodeKey(k)).map((k) => validName.test(k) ? safeKey(k) + ":r()" : "[" + JSON.stringify(k) + "]:r()").join(",") + "}") : new Function("r", "return {" + array.map((key) => validName.test(key) ? safeKey(key) + ":r()" : "[" + JSON.stringify(key) + "]:r()").join(",") + "}");
+      if (this.compiledReader)
+        compiledReader.next = this.compiledReader;
+      compiledReader.propertyCount = length;
+      this.compiledReader = compiledReader;
+      return compiledReader(read);
+    }
+    let object = {};
+    if (currentDecoder.keyMap) for (let i = 0; i < length; i++) object[safeKey(currentDecoder.decodeKey(this[i]))] = read();
+    else for (let i = 0; i < length; i++) {
+      object[safeKey(this[i])] = read();
+    }
+    return object;
+  }
+  structure.slowReads = 0;
+  return readObject;
+}
+function safeKey(key) {
+  if (typeof key === "string") return key === "__proto__" ? "__proto_" : key;
+  if (typeof key === "number" || typeof key === "boolean" || typeof key === "bigint") return key.toString();
+  if (key == null) return key + "";
+  throw new Error("Invalid property name type " + typeof key);
+}
+let readFixedString = readStringJS;
+function readStringJS(length) {
+  let result;
+  if (length < 16) {
+    if (result = shortStringInJS(length))
+      return result;
+  }
+  if (length > 64 && decoder)
+    return decoder.decode(src.subarray(position$1, position$1 += length));
+  const end = position$1 + length;
+  const units = [];
+  result = "";
+  while (position$1 < end) {
+    const byte1 = src[position$1++];
+    if ((byte1 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      const byte2 = src[position$1++] & 63;
+      const codePoint = (byte1 & 31) << 6 | byte2;
+      if (codePoint < 128) {
+        units.push(65533);
+      } else {
+        units.push(codePoint);
+      }
+    } else if ((byte1 & 240) === 224) {
+      const byte2 = src[position$1++] & 63;
+      const byte3 = src[position$1++] & 63;
+      const codePoint = (byte1 & 31) << 12 | byte2 << 6 | byte3;
+      if (codePoint < 2048 || codePoint >= 55296 && codePoint <= 57343) {
+        units.push(65533);
+      } else {
+        units.push(codePoint);
+      }
+    } else if ((byte1 & 248) === 240) {
+      const byte2 = src[position$1++] & 63;
+      const byte3 = src[position$1++] & 63;
+      const byte4 = src[position$1++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit < 65536 || unit > 1114111) {
+        units.push(65533);
+      } else if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+        units.push(unit);
+      } else {
+        units.push(unit);
+      }
+    } else {
+      units.push(65533);
+    }
+    if (units.length >= 4096) {
+      result += fromCharCode.apply(String, units);
+      units.length = 0;
+    }
+  }
+  if (units.length > 0) {
+    result += fromCharCode.apply(String, units);
+  }
+  return result;
+}
+let fromCharCode = String.fromCharCode;
+function longStringInJS(length) {
+  let start = position$1;
+  let bytes = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const byte = src[position$1++];
+    if ((byte & 128) > 0) {
+      position$1 = start;
+      return;
+    }
+    bytes[i] = byte;
+  }
+  return fromCharCode.apply(String, bytes);
+}
+function shortStringInJS(length) {
+  if (length < 4) {
+    if (length < 2) {
+      if (length === 0)
+        return "";
+      else {
+        let a = src[position$1++];
+        if ((a & 128) > 1) {
+          position$1 -= 1;
+          return;
+        }
+        return fromCharCode(a);
+      }
+    } else {
+      let a = src[position$1++];
+      let b = src[position$1++];
+      if ((a & 128) > 0 || (b & 128) > 0) {
+        position$1 -= 2;
+        return;
+      }
+      if (length < 3)
+        return fromCharCode(a, b);
+      let c = src[position$1++];
+      if ((c & 128) > 0) {
+        position$1 -= 3;
+        return;
+      }
+      return fromCharCode(a, b, c);
+    }
+  } else {
+    let a = src[position$1++];
+    let b = src[position$1++];
+    let c = src[position$1++];
+    let d = src[position$1++];
+    if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
+      position$1 -= 4;
+      return;
+    }
+    if (length < 6) {
+      if (length === 4)
+        return fromCharCode(a, b, c, d);
+      else {
+        let e = src[position$1++];
+        if ((e & 128) > 0) {
+          position$1 -= 5;
+          return;
+        }
+        return fromCharCode(a, b, c, d, e);
+      }
+    } else if (length < 8) {
+      let e = src[position$1++];
+      let f = src[position$1++];
+      if ((e & 128) > 0 || (f & 128) > 0) {
+        position$1 -= 6;
+        return;
+      }
+      if (length < 7)
+        return fromCharCode(a, b, c, d, e, f);
+      let g = src[position$1++];
+      if ((g & 128) > 0) {
+        position$1 -= 7;
+        return;
+      }
+      return fromCharCode(a, b, c, d, e, f, g);
+    } else {
+      let e = src[position$1++];
+      let f = src[position$1++];
+      let g = src[position$1++];
+      let h = src[position$1++];
+      if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
+        position$1 -= 8;
+        return;
+      }
+      if (length < 10) {
+        if (length === 8)
+          return fromCharCode(a, b, c, d, e, f, g, h);
+        else {
+          let i = src[position$1++];
+          if ((i & 128) > 0) {
+            position$1 -= 9;
+            return;
+          }
+          return fromCharCode(a, b, c, d, e, f, g, h, i);
+        }
+      } else if (length < 12) {
+        let i = src[position$1++];
+        let j = src[position$1++];
+        if ((i & 128) > 0 || (j & 128) > 0) {
+          position$1 -= 10;
+          return;
+        }
+        if (length < 11)
+          return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+        let k = src[position$1++];
+        if ((k & 128) > 0) {
+          position$1 -= 11;
+          return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+      } else {
+        let i = src[position$1++];
+        let j = src[position$1++];
+        let k = src[position$1++];
+        let l = src[position$1++];
+        if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
+          position$1 -= 12;
+          return;
+        }
+        if (length < 14) {
+          if (length === 12)
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+          else {
+            let m = src[position$1++];
+            if ((m & 128) > 0) {
+              position$1 -= 13;
+              return;
+            }
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+          }
+        } else {
+          let m = src[position$1++];
+          let n = src[position$1++];
+          if ((m & 128) > 0 || (n & 128) > 0) {
+            position$1 -= 14;
+            return;
+          }
+          if (length < 15)
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+          let o = src[position$1++];
+          if ((o & 128) > 0) {
+            position$1 -= 15;
+            return;
+          }
+          return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+        }
+      }
+    }
+  }
+}
+function readBin(length) {
+  return currentDecoder.copyBuffers ? (
+    // specifically use the copying slice (not the node one)
+    Uint8Array.prototype.slice.call(src, position$1, position$1 += length)
+  ) : src.subarray(position$1, position$1 += length);
+}
+let f32Array = new Float32Array(1);
+let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+function getFloat16() {
+  let byte0 = src[position$1++];
+  let byte1 = src[position$1++];
+  let exponent = (byte0 & 127) >> 2;
+  if (exponent === 31) {
+    if (byte1 || byte0 & 3)
+      return NaN;
+    return byte0 & 128 ? -Infinity : Infinity;
+  }
+  if (exponent === 0) {
+    let abs = ((byte0 & 3) << 8 | byte1) / (1 << 24);
+    return byte0 & 128 ? -abs : abs;
+  }
+  u8Array[3] = byte0 & 128 | // sign bit
+  (exponent >> 1) + 56;
+  u8Array[2] = (byte0 & 7) << 5 | // last exponent bit and first two mantissa bits
+  byte1 >> 3;
+  u8Array[1] = byte1 << 5;
+  u8Array[0] = 0;
+  return f32Array[0];
+}
+new Array(4096);
+class Tag {
+  constructor(value, tag) {
+    this.value = value;
+    this.tag = tag;
+  }
+}
+currentExtensions[0] = (dateString) => {
+  return new Date(dateString);
+};
+currentExtensions[1] = (epochSec) => {
+  return new Date(Math.round(epochSec * 1e3));
+};
+currentExtensions[2] = (buffer) => {
+  let value = BigInt(0);
+  for (let i = 0, l = buffer.byteLength; i < l; i++) {
+    value = BigInt(buffer[i]) + (value << BigInt(8));
+  }
+  return value;
+};
+currentExtensions[3] = (buffer) => {
+  return BigInt(-1) - currentExtensions[2](buffer);
+};
+currentExtensions[4] = (fraction) => {
+  return +(fraction[1] + "e" + fraction[0]);
+};
+currentExtensions[5] = (fraction) => {
+  return fraction[1] * Math.exp(fraction[0] * Math.log(2));
+};
+const recordDefinition = (id, structure) => {
+  id = id - 57344;
+  let existingStructure = currentStructures[id];
+  if (existingStructure && existingStructure.isShared) {
+    (currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
+  }
+  currentStructures[id] = structure;
+  structure.read = createStructureReader(structure);
+};
+currentExtensions[LEGACY_RECORD_INLINE_ID] = (data) => {
+  let length = data.length;
+  let structure = data[1];
+  recordDefinition(data[0], structure);
+  let object = {};
+  for (let i = 2; i < length; i++) {
+    let key = structure[i - 2];
+    object[safeKey(key)] = data[i];
+  }
+  return object;
+};
+currentExtensions[14] = (value) => {
+  if (bundledStrings$1)
+    return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 += value);
+  return new Tag(value, 14);
+};
+currentExtensions[15] = (value) => {
+  if (bundledStrings$1)
+    return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value);
+  return new Tag(value, 15);
+};
+let glbl = { Error, RegExp };
+currentExtensions[27] = (data) => {
+  return (glbl[data[0]] || Error)(data[1], data[2]);
+};
+const packedTable = (read2) => {
+  if (src[position$1++] != 132) {
+    let error = new Error("Packed values structure must be followed by a 4 element array");
+    if (src.length < position$1)
+      error.incomplete = true;
+    throw error;
+  }
+  let newPackedValues = read2();
+  if (!newPackedValues || !newPackedValues.length) {
+    let error = new Error("Packed values structure must be followed by a 4 element array");
+    error.incomplete = true;
+    throw error;
+  }
+  packedValues = packedValues ? newPackedValues.concat(packedValues.slice(newPackedValues.length)) : newPackedValues;
+  packedValues.prefixes = read2();
+  packedValues.suffixes = read2();
+  return read2();
+};
+packedTable.handlesRead = true;
+currentExtensions[51] = packedTable;
+currentExtensions[PACKED_REFERENCE_TAG_ID] = (data) => {
+  if (!packedValues) {
+    if (currentDecoder.getShared)
+      loadShared();
+    else
+      return new Tag(data, PACKED_REFERENCE_TAG_ID);
+  }
+  if (typeof data == "number")
+    return packedValues[16 + (data >= 0 ? 2 * data : -2 * data - 1)];
+  let error = new Error("No support for non-integer packed references yet");
+  if (data === void 0)
+    error.incomplete = true;
+  throw error;
+};
+currentExtensions[28] = (read2) => {
+  if (!referenceMap) {
+    referenceMap = /* @__PURE__ */ new Map();
+    referenceMap.id = 0;
+  }
+  let id = referenceMap.id++;
+  let startingPosition = position$1;
+  let token = src[position$1];
+  let target2;
+  if (token >> 5 == 4)
+    target2 = [];
+  else
+    target2 = {};
+  let refEntry = { target: target2 };
+  referenceMap.set(id, refEntry);
+  let targetProperties = read2();
+  if (refEntry.used) {
+    if (Object.getPrototypeOf(target2) !== Object.getPrototypeOf(targetProperties)) {
+      position$1 = startingPosition;
+      target2 = targetProperties;
+      referenceMap.set(id, { target: target2 });
+      targetProperties = read2();
+    }
+    return Object.assign(target2, targetProperties);
+  }
+  refEntry.target = targetProperties;
+  return targetProperties;
+};
+currentExtensions[28].handlesRead = true;
+currentExtensions[29] = (id) => {
+  let refEntry = referenceMap.get(id);
+  refEntry.used = true;
+  return refEntry.target;
+};
+currentExtensions[258] = (array) => new Set(array);
+(currentExtensions[259] = (read2) => {
+  if (currentDecoder.mapsAsObjects) {
+    currentDecoder.mapsAsObjects = false;
+    restoreMapsAsObject = true;
+  }
+  return read2();
+}).handlesRead = true;
+function combine(a, b) {
+  if (typeof a === "string")
+    return a + b;
+  if (a instanceof Array)
+    return a.concat(b);
+  return Object.assign({}, a, b);
+}
+function getPackedValues() {
+  if (!packedValues) {
+    if (currentDecoder.getShared)
+      loadShared();
+    else
+      throw new Error("No packed values available");
+  }
+  return packedValues;
+}
+const SHARED_DATA_TAG_ID = 1399353956;
+currentExtensionRanges.push((tag, input) => {
+  if (tag >= 225 && tag <= 255)
+    return combine(getPackedValues().prefixes[tag - 224], input);
+  if (tag >= 28704 && tag <= 32767)
+    return combine(getPackedValues().prefixes[tag - 28672], input);
+  if (tag >= 1879052288 && tag <= 2147483647)
+    return combine(getPackedValues().prefixes[tag - 1879048192], input);
+  if (tag >= 216 && tag <= 223)
+    return combine(input, getPackedValues().suffixes[tag - 216]);
+  if (tag >= 27647 && tag <= 28671)
+    return combine(input, getPackedValues().suffixes[tag - 27639]);
+  if (tag >= 1811940352 && tag <= 1879048191)
+    return combine(input, getPackedValues().suffixes[tag - 1811939328]);
+  if (tag == SHARED_DATA_TAG_ID) {
+    return {
+      packedValues,
+      structures: currentStructures.slice(0),
+      version: input
+    };
+  }
+  if (tag == 55799)
+    return input;
+});
+const isLittleEndianMachine$1 = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+const typedArrays = [
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  typeof BigUint64Array == "undefined" ? { name: "BigUint64Array" } : BigUint64Array,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  typeof BigInt64Array == "undefined" ? { name: "BigInt64Array" } : BigInt64Array,
+  Float32Array,
+  Float64Array
+];
+const typedArrayTags = [64, 68, 69, 70, 71, 72, 77, 78, 79, 85, 86];
+for (let i = 0; i < typedArrays.length; i++) {
+  registerTypedArray(typedArrays[i], typedArrayTags[i]);
+}
+function registerTypedArray(TypedArray, tag) {
+  let dvMethod = "get" + TypedArray.name.slice(0, -5);
+  let bytesPerElement;
+  if (typeof TypedArray === "function")
+    bytesPerElement = TypedArray.BYTES_PER_ELEMENT;
+  else
+    TypedArray = null;
+  for (let littleEndian = 0; littleEndian < 2; littleEndian++) {
+    if (!littleEndian && bytesPerElement == 1)
+      continue;
+    let sizeShift = bytesPerElement == 2 ? 1 : bytesPerElement == 4 ? 2 : bytesPerElement == 8 ? 3 : 0;
+    currentExtensions[littleEndian ? tag : tag - 4] = bytesPerElement == 1 || littleEndian == isLittleEndianMachine$1 ? (buffer) => {
+      if (!TypedArray)
+        throw new Error("Could not find typed array for code " + tag);
+      if (!currentDecoder.copyBuffers) {
+        if (bytesPerElement === 1 || bytesPerElement === 2 && !(buffer.byteOffset & 1) || bytesPerElement === 4 && !(buffer.byteOffset & 3) || bytesPerElement === 8 && !(buffer.byteOffset & 7))
+          return new TypedArray(buffer.buffer, buffer.byteOffset, buffer.byteLength >> sizeShift);
+      }
+      return new TypedArray(Uint8Array.prototype.slice.call(buffer, 0).buffer);
+    } : (buffer) => {
+      if (!TypedArray)
+        throw new Error("Could not find typed array for code " + tag);
+      let dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      let elements = buffer.length >> sizeShift;
+      let ta = new TypedArray(elements);
+      let method = dv[dvMethod];
+      for (let i = 0; i < elements; i++) {
+        ta[i] = method.call(dv, i << sizeShift, littleEndian);
+      }
+      return ta;
+    };
+  }
+}
+function readBundleExt() {
+  let length = readJustLength();
+  let bundlePosition = position$1 + read();
+  for (let i = 2; i < length; i++) {
+    let bundleLength = readJustLength();
+    position$1 += bundleLength;
+  }
+  let dataPosition = position$1;
+  position$1 = bundlePosition;
+  bundledStrings$1 = [readStringJS(readJustLength()), readStringJS(readJustLength())];
+  bundledStrings$1.position0 = 0;
+  bundledStrings$1.position1 = 0;
+  bundledStrings$1.postBundlePosition = position$1;
+  position$1 = dataPosition;
+  return read();
+}
+function readJustLength() {
+  let token = src[position$1++] & 31;
+  if (token > 23) {
+    switch (token) {
+      case 24:
+        token = src[position$1++];
+        break;
+      case 25:
+        token = dataView.getUint16(position$1);
+        position$1 += 2;
+        break;
+      case 26:
+        token = dataView.getUint32(position$1);
+        position$1 += 4;
+        break;
+    }
+  }
+  return token;
+}
+function loadShared() {
+  if (currentDecoder.getShared) {
+    let sharedData = saveState(() => {
+      src = null;
+      return currentDecoder.getShared();
+    }) || {};
+    let updatedStructures = sharedData.structures || [];
+    currentDecoder.sharedVersion = sharedData.version;
+    packedValues = currentDecoder.sharedValues = sharedData.packedValues;
+    if (currentStructures === true)
+      currentDecoder.structures = currentStructures = updatedStructures;
+    else
+      currentStructures.splice.apply(currentStructures, [0, updatedStructures.length].concat(updatedStructures));
+  }
+}
+function saveState(callback) {
+  let savedSrcEnd = srcEnd;
+  let savedPosition = position$1;
+  let savedSrcStringStart = srcStringStart;
+  let savedSrcStringEnd = srcStringEnd;
+  let savedSrcString = srcString;
+  let savedReferenceMap = referenceMap;
+  let savedBundledStrings = bundledStrings$1;
+  let savedSrc = new Uint8Array(src.slice(0, srcEnd));
+  let savedStructures = currentStructures;
+  let savedDecoder = currentDecoder;
+  let savedSequentialMode = sequentialMode;
+  let value = callback();
+  srcEnd = savedSrcEnd;
+  position$1 = savedPosition;
+  srcStringStart = savedSrcStringStart;
+  srcStringEnd = savedSrcStringEnd;
+  srcString = savedSrcString;
+  referenceMap = savedReferenceMap;
+  bundledStrings$1 = savedBundledStrings;
+  src = savedSrc;
+  sequentialMode = savedSequentialMode;
+  currentStructures = savedStructures;
+  currentDecoder = savedDecoder;
+  dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  return value;
+}
+function clearSource() {
+  src = null;
+  referenceMap = null;
+  currentStructures = null;
+}
+const mult10 = new Array(147);
+for (let i = 0; i < 256; i++) {
+  mult10[i] = +("1e" + Math.floor(45.15 - i * 0.30103));
+}
+let defaultDecoder = new Decoder({ useRecords: false });
+defaultDecoder.decode;
+defaultDecoder.decodeMultiple;
+let textEncoder;
+try {
+  textEncoder = new TextEncoder();
+} catch (error) {
+}
+let extensions, extensionClasses;
+const Buffer$1 = typeof globalThis === "object" && globalThis.Buffer;
+const hasNodeBuffer = typeof Buffer$1 !== "undefined";
+const ByteArrayAllocate = hasNodeBuffer ? Buffer$1.allocUnsafeSlow : Uint8Array;
+const ByteArray = hasNodeBuffer ? Buffer$1 : Uint8Array;
+const MAX_STRUCTURES = 256;
+const MAX_BUFFER_SIZE = hasNodeBuffer ? 4294967296 : 2144337920;
+let throwOnIterable;
+let target;
+let targetView;
+let position = 0;
+let safeEnd;
+let bundledStrings = null;
+const MAX_BUNDLE_SIZE = 61440;
+const hasNonLatin = /[\u0080-\uFFFF]/;
+const RECORD_SYMBOL = Symbol("record-id");
+class Encoder extends Decoder {
+  constructor(options) {
+    super(options);
+    this.offset = 0;
+    let start;
+    let sharedStructures;
+    let hasSharedUpdate;
+    let structures;
+    let referenceMap2;
+    options = options || {};
+    let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position2) {
+      return target.utf8Write(string, position2, target.byteLength - position2);
+    } : textEncoder && textEncoder.encodeInto ? function(string, position2) {
+      return textEncoder.encodeInto(string, target.subarray(position2)).written;
+    } : false;
+    let encoder = this;
+    let hasSharedStructures = options.structures || options.saveStructures;
+    let maxSharedStructures = options.maxSharedStructures;
+    if (maxSharedStructures == null)
+      maxSharedStructures = hasSharedStructures ? 128 : 0;
+    if (maxSharedStructures > 8190)
+      throw new Error("Maximum maxSharedStructure is 8190");
+    let isSequential = options.sequential;
+    if (isSequential) {
+      maxSharedStructures = 0;
+    }
+    if (!this.structures)
+      this.structures = [];
+    if (this.saveStructures)
+      this.saveShared = this.saveStructures;
+    let samplingPackedValues, packedObjectMap2, sharedValues = options.sharedValues;
+    let sharedPackedObjectMap2;
+    if (sharedValues) {
+      sharedPackedObjectMap2 = /* @__PURE__ */ Object.create(null);
+      for (let i = 0, l = sharedValues.length; i < l; i++) {
+        sharedPackedObjectMap2[sharedValues[i]] = i;
+      }
+    }
+    let recordIdsToRemove = [];
+    let transitionsCount = 0;
+    let serializationsSinceTransitionRebuild = 0;
+    this.mapEncode = function(value, encodeOptions) {
+      if (this._keyMap && !this._mapped) {
+        switch (value.constructor.name) {
+          case "Array":
+            value = value.map((r) => this.encodeKeys(r));
+            break;
+        }
+      }
+      return this.encode(value, encodeOptions);
+    };
+    this.encode = function(value, encodeOptions) {
+      if (!target) {
+        target = new ByteArrayAllocate(8192);
+        targetView = new DataView(target.buffer, 0, 8192);
+        position = 0;
+      }
+      safeEnd = target.length - 10;
+      if (safeEnd - position < 2048) {
+        target = new ByteArrayAllocate(target.length);
+        targetView = new DataView(target.buffer, 0, target.length);
+        safeEnd = target.length - 10;
+        position = 0;
+      } else if (encodeOptions === REUSE_BUFFER_MODE)
+        position = position + 7 & 2147483640;
+      start = position;
+      if (encoder.useSelfDescribedHeader) {
+        targetView.setUint32(position, 3654940416);
+        position += 3;
+      }
+      referenceMap2 = encoder.structuredClone ? /* @__PURE__ */ new Map() : null;
+      if (encoder.bundleStrings && typeof value !== "string") {
+        bundledStrings = [];
+        bundledStrings.size = Infinity;
+      } else
+        bundledStrings = null;
+      sharedStructures = encoder.structures;
+      if (sharedStructures) {
+        if (sharedStructures.uninitialized) {
+          let sharedData = encoder.getShared() || {};
+          encoder.structures = sharedStructures = sharedData.structures || [];
+          encoder.sharedVersion = sharedData.version;
+          let sharedValues2 = encoder.sharedValues = sharedData.packedValues;
+          if (sharedValues2) {
+            sharedPackedObjectMap2 = {};
+            for (let i = 0, l = sharedValues2.length; i < l; i++)
+              sharedPackedObjectMap2[sharedValues2[i]] = i;
+          }
+        }
+        let sharedStructuresLength = sharedStructures.length;
+        if (sharedStructuresLength > maxSharedStructures && !isSequential)
+          sharedStructuresLength = maxSharedStructures;
+        if (!sharedStructures.transitions) {
+          sharedStructures.transitions = /* @__PURE__ */ Object.create(null);
+          for (let i = 0; i < sharedStructuresLength; i++) {
+            let keys = sharedStructures[i];
+            if (!keys)
+              continue;
+            let nextTransition, transition = sharedStructures.transitions;
+            for (let j = 0, l = keys.length; j < l; j++) {
+              if (transition[RECORD_SYMBOL] === void 0)
+                transition[RECORD_SYMBOL] = i;
+              let key = keys[j];
+              nextTransition = transition[key];
+              if (!nextTransition) {
+                nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
+              }
+              transition = nextTransition;
+            }
+            transition[RECORD_SYMBOL] = i | 1048576;
+          }
+        }
+        if (!isSequential)
+          sharedStructures.nextId = sharedStructuresLength;
+      }
+      if (hasSharedUpdate)
+        hasSharedUpdate = false;
+      structures = sharedStructures || [];
+      packedObjectMap2 = sharedPackedObjectMap2;
+      if (options.pack) {
+        let packedValues2 = /* @__PURE__ */ new Map();
+        packedValues2.values = [];
+        packedValues2.encoder = encoder;
+        packedValues2.maxValues = options.maxPrivatePackedValues || (sharedPackedObjectMap2 ? 16 : Infinity);
+        packedValues2.objectMap = sharedPackedObjectMap2 || false;
+        packedValues2.samplingPackedValues = samplingPackedValues;
+        findRepetitiveStrings(value, packedValues2);
+        if (packedValues2.values.length > 0) {
+          target[position++] = 216;
+          target[position++] = 51;
+          writeArrayHeader(4);
+          let valuesArray = packedValues2.values;
+          encode2(valuesArray);
+          writeArrayHeader(0);
+          writeArrayHeader(0);
+          packedObjectMap2 = Object.create(sharedPackedObjectMap2 || null);
+          for (let i = 0, l = valuesArray.length; i < l; i++) {
+            packedObjectMap2[valuesArray[i]] = i;
+          }
+        }
+      }
+      throwOnIterable = encodeOptions & THROW_ON_ITERABLE;
+      try {
+        if (throwOnIterable)
+          return;
+        encode2(value);
+        if (bundledStrings) {
+          writeBundles(start, encode2);
+        }
+        encoder.offset = position;
+        if (referenceMap2 && referenceMap2.idsToInsert) {
+          position += referenceMap2.idsToInsert.length * 2;
+          if (position > safeEnd)
+            makeRoom(position);
+          encoder.offset = position;
+          let serialized = insertIds(target.subarray(start, position), referenceMap2.idsToInsert);
+          referenceMap2 = null;
+          return serialized;
+        }
+        if (encodeOptions & REUSE_BUFFER_MODE) {
+          target.start = start;
+          target.end = position;
+          return target;
+        }
+        return target.subarray(start, position);
+      } finally {
+        if (sharedStructures) {
+          if (serializationsSinceTransitionRebuild < 10)
+            serializationsSinceTransitionRebuild++;
+          if (sharedStructures.length > maxSharedStructures)
+            sharedStructures.length = maxSharedStructures;
+          if (transitionsCount > 1e4) {
+            sharedStructures.transitions = null;
+            serializationsSinceTransitionRebuild = 0;
+            transitionsCount = 0;
+            if (recordIdsToRemove.length > 0)
+              recordIdsToRemove = [];
+          } else if (recordIdsToRemove.length > 0 && !isSequential) {
+            for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
+              recordIdsToRemove[i][RECORD_SYMBOL] = void 0;
+            }
+            recordIdsToRemove = [];
+          }
+        }
+        if (hasSharedUpdate && encoder.saveShared) {
+          if (encoder.structures.length > maxSharedStructures) {
+            encoder.structures = encoder.structures.slice(0, maxSharedStructures);
+          }
+          let returnBuffer = target.subarray(start, position);
+          if (encoder.updateSharedData() === false)
+            return encoder.encode(value);
+          return returnBuffer;
+        }
+        if (encodeOptions & RESET_BUFFER_MODE)
+          position = start;
+      }
+    };
+    this.findCommonStringsToPack = () => {
+      samplingPackedValues = /* @__PURE__ */ new Map();
+      if (!sharedPackedObjectMap2)
+        sharedPackedObjectMap2 = /* @__PURE__ */ Object.create(null);
+      return (options2) => {
+        let threshold = options2 && options2.threshold || 4;
+        let position2 = this.pack ? options2.maxPrivatePackedValues || 16 : 0;
+        if (!sharedValues)
+          sharedValues = this.sharedValues = [];
+        for (let [key, status] of samplingPackedValues) {
+          if (status.count > threshold) {
+            sharedPackedObjectMap2[key] = position2++;
+            sharedValues.push(key);
+            hasSharedUpdate = true;
+          }
+        }
+        while (this.saveShared && this.updateSharedData() === false) {
+        }
+        samplingPackedValues = null;
+      };
+    };
+    const encode2 = (value) => {
+      if (position > safeEnd)
+        target = makeRoom(position);
+      var type = typeof value;
+      var length;
+      if (type === "string") {
+        if (packedObjectMap2) {
+          let packedPosition = packedObjectMap2[value];
+          if (packedPosition >= 0) {
+            if (packedPosition < 16)
+              target[position++] = packedPosition + 224;
+            else {
+              target[position++] = 198;
+              if (packedPosition & 1)
+                encode2(15 - packedPosition >> 1);
+              else
+                encode2(packedPosition - 16 >> 1);
+            }
+            return;
+          } else if (samplingPackedValues && !options.pack) {
+            let status = samplingPackedValues.get(value);
+            if (status)
+              status.count++;
+            else
+              samplingPackedValues.set(value, {
+                count: 1
+              });
+          }
+        }
+        let strLength = value.length;
+        if (bundledStrings && strLength >= 4 && strLength < 1024) {
+          if ((bundledStrings.size += strLength) > MAX_BUNDLE_SIZE) {
+            let extStart;
+            let maxBytes2 = (bundledStrings[0] ? bundledStrings[0].length * 3 + bundledStrings[1].length : 0) + 10;
+            if (position + maxBytes2 > safeEnd)
+              target = makeRoom(position + maxBytes2);
+            target[position++] = 217;
+            target[position++] = 223;
+            target[position++] = 249;
+            target[position++] = bundledStrings.position ? 132 : 130;
+            target[position++] = 26;
+            extStart = position - start;
+            position += 4;
+            if (bundledStrings.position) {
+              writeBundles(start, encode2);
+            }
+            bundledStrings = ["", ""];
+            bundledStrings.size = 0;
+            bundledStrings.position = extStart;
+          }
+          let twoByte = hasNonLatin.test(value);
+          bundledStrings[twoByte ? 0 : 1] += value;
+          target[position++] = twoByte ? 206 : 207;
+          encode2(strLength);
+          return;
+        }
+        let headerSize;
+        if (strLength < 32) {
+          headerSize = 1;
+        } else if (strLength < 256) {
+          headerSize = 2;
+        } else if (strLength < 65536) {
+          headerSize = 3;
+        } else {
+          headerSize = 5;
+        }
+        let maxBytes = strLength * 3;
+        if (position + maxBytes > safeEnd)
+          target = makeRoom(position + maxBytes);
+        if (strLength < 64 || !encodeUtf8) {
+          let i, c1, c2, strPosition = position + headerSize;
+          for (i = 0; i < strLength; i++) {
+            c1 = value.charCodeAt(i);
+            if (c1 < 128) {
+              target[strPosition++] = c1;
+            } else if (c1 < 2048) {
+              target[strPosition++] = c1 >> 6 | 192;
+              target[strPosition++] = c1 & 63 | 128;
+            } else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
+              c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+              i++;
+              target[strPosition++] = c1 >> 18 | 240;
+              target[strPosition++] = c1 >> 12 & 63 | 128;
+              target[strPosition++] = c1 >> 6 & 63 | 128;
+              target[strPosition++] = c1 & 63 | 128;
+            } else {
+              target[strPosition++] = c1 >> 12 | 224;
+              target[strPosition++] = c1 >> 6 & 63 | 128;
+              target[strPosition++] = c1 & 63 | 128;
+            }
+          }
+          length = strPosition - position - headerSize;
+        } else {
+          length = encodeUtf8(value, position + headerSize, maxBytes);
+        }
+        if (length < 24) {
+          target[position++] = 96 | length;
+        } else if (length < 256) {
+          if (headerSize < 2) {
+            target.copyWithin(position + 2, position + 1, position + 1 + length);
+          }
+          target[position++] = 120;
+          target[position++] = length;
+        } else if (length < 65536) {
+          if (headerSize < 3) {
+            target.copyWithin(position + 3, position + 2, position + 2 + length);
+          }
+          target[position++] = 121;
+          target[position++] = length >> 8;
+          target[position++] = length & 255;
+        } else {
+          if (headerSize < 5) {
+            target.copyWithin(position + 5, position + 3, position + 3 + length);
+          }
+          target[position++] = 122;
+          targetView.setUint32(position, length);
+          position += 4;
+        }
+        position += length;
+      } else if (type === "number") {
+        if (!this.alwaysUseFloat && value >>> 0 === value) {
+          if (value < 24) {
+            target[position++] = value;
+          } else if (value < 256) {
+            target[position++] = 24;
+            target[position++] = value;
+          } else if (value < 65536) {
+            target[position++] = 25;
+            target[position++] = value >> 8;
+            target[position++] = value & 255;
+          } else {
+            target[position++] = 26;
+            targetView.setUint32(position, value);
+            position += 4;
+          }
+        } else if (!this.alwaysUseFloat && value >> 0 === value) {
+          if (value >= -24) {
+            target[position++] = 31 - value;
+          } else if (value >= -256) {
+            target[position++] = 56;
+            target[position++] = ~value;
+          } else if (value >= -65536) {
+            target[position++] = 57;
+            targetView.setUint16(position, ~value);
+            position += 2;
+          } else {
+            target[position++] = 58;
+            targetView.setUint32(position, ~value);
+            position += 4;
+          }
+        } else if (!this.alwaysUseFloat && value < 0 && value >= -4294967296 && Math.floor(value) === value) {
+          target[position++] = 58;
+          targetView.setUint32(position, -1 - value);
+          position += 4;
+        } else {
+          let useFloat32;
+          if ((useFloat32 = this.useFloat32) > 0 && value < 4294967296 && value >= -2147483648) {
+            target[position++] = 250;
+            targetView.setFloat32(position, value);
+            let xShifted;
+            if (useFloat32 < 4 || // this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
+            (xShifted = value * mult10[(target[position] & 127) << 1 | target[position + 1] >> 7]) >> 0 === xShifted) {
+              position += 4;
+              return;
+            } else
+              position--;
+          }
+          target[position++] = 251;
+          targetView.setFloat64(position, value);
+          position += 8;
+        }
+      } else if (type === "object") {
+        if (!value)
+          target[position++] = 246;
+        else {
+          if (referenceMap2) {
+            let referee = referenceMap2.get(value);
+            if (referee) {
+              target[position++] = 216;
+              target[position++] = 29;
+              target[position++] = 25;
+              if (!referee.references) {
+                let idsToInsert = referenceMap2.idsToInsert || (referenceMap2.idsToInsert = []);
+                referee.references = [];
+                idsToInsert.push(referee);
+              }
+              referee.references.push(position - start);
+              position += 2;
+              return;
+            } else
+              referenceMap2.set(value, { offset: position - start });
+          }
+          let constructor = value.constructor;
+          if (constructor === Object) {
+            if (this.skipFunction === true) {
+              value = Object.fromEntries([...Object.keys(value).filter((x) => typeof value[x] !== "function").map((x) => [x, value[x]])]);
+            }
+            writeObject(value);
+          } else if (constructor === Array) {
+            length = value.length;
+            if (length < 24) {
+              target[position++] = 128 | length;
+            } else {
+              writeArrayHeader(length);
+            }
+            for (let i = 0; i < length; i++) {
+              encode2(value[i]);
+            }
+          } else if (constructor === Map) {
+            if (this.mapsAsObjects ? this.useTag259ForMaps !== false : this.useTag259ForMaps) {
+              target[position++] = 217;
+              target[position++] = 1;
+              target[position++] = 3;
+            }
+            length = value.size;
+            if (length < 24) {
+              target[position++] = 160 | length;
+            } else if (length < 256) {
+              target[position++] = 184;
+              target[position++] = length;
+            } else if (length < 65536) {
+              target[position++] = 185;
+              target[position++] = length >> 8;
+              target[position++] = length & 255;
+            } else {
+              target[position++] = 186;
+              targetView.setUint32(position, length);
+              position += 4;
+            }
+            if (encoder.keyMap) {
+              for (let [key, entryValue] of value) {
+                encode2(encoder.encodeKey(key));
+                encode2(entryValue);
+              }
+            } else {
+              for (let [key, entryValue] of value) {
+                encode2(key);
+                encode2(entryValue);
+              }
+            }
+          } else {
+            for (let i = 0, l = extensions.length; i < l; i++) {
+              let extensionClass = extensionClasses[i];
+              if (value instanceof extensionClass) {
+                let extension = extensions[i];
+                let tag = extension.tag;
+                if (tag == void 0)
+                  tag = extension.getTag && extension.getTag.call(this, value);
+                if (tag < 24) {
+                  target[position++] = 192 | tag;
+                } else if (tag < 256) {
+                  target[position++] = 216;
+                  target[position++] = tag;
+                } else if (tag < 65536) {
+                  target[position++] = 217;
+                  target[position++] = tag >> 8;
+                  target[position++] = tag & 255;
+                } else if (tag > -1) {
+                  target[position++] = 218;
+                  targetView.setUint32(position, tag);
+                  position += 4;
+                }
+                extension.encode.call(this, value, encode2, makeRoom);
+                return;
+              }
+            }
+            if (value[Symbol.iterator]) {
+              if (throwOnIterable) {
+                let error = new Error("Iterable should be serialized as iterator");
+                error.iteratorNotHandled = true;
+                throw error;
+              }
+              target[position++] = 159;
+              for (let entry of value) {
+                encode2(entry);
+              }
+              target[position++] = 255;
+              return;
+            }
+            if (value[Symbol.asyncIterator] || isBlob(value)) {
+              let error = new Error("Iterable/blob should be serialized as iterator");
+              error.iteratorNotHandled = true;
+              throw error;
+            }
+            if (this.useToJSON && value.toJSON) {
+              const json = value.toJSON();
+              if (json !== value)
+                return encode2(json);
+            }
+            writeObject(value);
+          }
+        }
+      } else if (type === "boolean") {
+        target[position++] = value ? 245 : 244;
+      } else if (type === "bigint") {
+        if (value < BigInt(1) << BigInt(64) && value >= 0) {
+          target[position++] = 27;
+          targetView.setBigUint64(position, value);
+        } else if (value > -(BigInt(1) << BigInt(64)) && value < 0) {
+          target[position++] = 59;
+          targetView.setBigUint64(position, -value - BigInt(1));
+        } else {
+          if (this.largeBigIntToFloat) {
+            target[position++] = 251;
+            targetView.setFloat64(position, Number(value));
+          } else {
+            if (value >= BigInt(0))
+              target[position++] = 194;
+            else {
+              target[position++] = 195;
+              value = BigInt(-1) - value;
+            }
+            let bytes = [];
+            while (value) {
+              bytes.push(Number(value & BigInt(255)));
+              value >>= BigInt(8);
+            }
+            writeBuffer(new Uint8Array(bytes.reverse()), makeRoom);
+            return;
+          }
+        }
+        position += 8;
+      } else if (type === "undefined") {
+        target[position++] = 247;
+      } else {
+        throw new Error("Unknown type: " + type);
+      }
+    };
+    const writeObject = this.useRecords === false ? this.variableMapSize ? (object) => {
+      let keys = Object.keys(object);
+      let vals = Object.values(object);
+      let length = keys.length;
+      if (length < 24) {
+        target[position++] = 160 | length;
+      } else if (length < 256) {
+        target[position++] = 184;
+        target[position++] = length;
+      } else if (length < 65536) {
+        target[position++] = 185;
+        target[position++] = length >> 8;
+        target[position++] = length & 255;
+      } else {
+        target[position++] = 186;
+        targetView.setUint32(position, length);
+        position += 4;
+      }
+      if (encoder.keyMap) {
+        for (let i = 0; i < length; i++) {
+          encode2(encoder.encodeKey(keys[i]));
+          encode2(vals[i]);
+        }
+      } else {
+        for (let i = 0; i < length; i++) {
+          encode2(keys[i]);
+          encode2(vals[i]);
+        }
+      }
+    } : (object) => {
+      target[position++] = 185;
+      let objectOffset = position - start;
+      position += 2;
+      let size = 0;
+      if (encoder.keyMap) {
+        for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+          encode2(encoder.encodeKey(key));
+          encode2(object[key]);
+          size++;
+        }
+      } else {
+        for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+          encode2(key);
+          encode2(object[key]);
+          size++;
+        }
+      }
+      target[objectOffset++ + start] = size >> 8;
+      target[objectOffset + start] = size & 255;
+    } : (object, skipValues) => {
+      let nextTransition, transition = structures.transitions || (structures.transitions = /* @__PURE__ */ Object.create(null));
+      let newTransitions = 0;
+      let length = 0;
+      let parentRecordId;
+      let keys;
+      if (this.keyMap) {
+        keys = Object.keys(object).map((k) => this.encodeKey(k));
+        length = keys.length;
+        for (let i = 0; i < length; i++) {
+          let key = keys[i];
+          nextTransition = transition[key];
+          if (!nextTransition) {
+            nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
+            newTransitions++;
+          }
+          transition = nextTransition;
+        }
+      } else {
+        for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+          nextTransition = transition[key];
+          if (!nextTransition) {
+            if (transition[RECORD_SYMBOL] & 1048576) {
+              parentRecordId = transition[RECORD_SYMBOL] & 65535;
+            }
+            nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
+            newTransitions++;
+          }
+          transition = nextTransition;
+          length++;
+        }
+      }
+      let recordId = transition[RECORD_SYMBOL];
+      if (recordId !== void 0) {
+        recordId &= 65535;
+        target[position++] = 217;
+        target[position++] = recordId >> 8 | 224;
+        target[position++] = recordId & 255;
+      } else {
+        if (!keys)
+          keys = transition.__keys__ || (transition.__keys__ = Object.keys(object));
+        if (parentRecordId === void 0) {
+          recordId = structures.nextId++;
+          if (!recordId) {
+            recordId = 0;
+            structures.nextId = 1;
+          }
+          if (recordId >= MAX_STRUCTURES) {
+            structures.nextId = (recordId = maxSharedStructures) + 1;
+          }
+        } else {
+          recordId = parentRecordId;
+        }
+        structures[recordId] = keys;
+        if (recordId < maxSharedStructures) {
+          target[position++] = 217;
+          target[position++] = recordId >> 8 | 224;
+          target[position++] = recordId & 255;
+          transition = structures.transitions;
+          for (let i = 0; i < length; i++) {
+            if (transition[RECORD_SYMBOL] === void 0 || transition[RECORD_SYMBOL] & 1048576)
+              transition[RECORD_SYMBOL] = recordId;
+            transition = transition[keys[i]];
+          }
+          transition[RECORD_SYMBOL] = recordId | 1048576;
+          hasSharedUpdate = true;
+        } else {
+          transition[RECORD_SYMBOL] = recordId;
+          targetView.setUint32(position, 3655335680);
+          position += 3;
+          if (newTransitions)
+            transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
+          if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures)
+            recordIdsToRemove.shift()[RECORD_SYMBOL] = void 0;
+          recordIdsToRemove.push(transition);
+          writeArrayHeader(length + 2);
+          encode2(57344 + recordId);
+          encode2(keys);
+          if (skipValues) return;
+          for (let key in object)
+            if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key))
+              encode2(object[key]);
+          return;
+        }
+      }
+      if (length < 24) {
+        target[position++] = 128 | length;
+      } else {
+        writeArrayHeader(length);
+      }
+      if (skipValues) return;
+      for (let key in object)
+        if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key))
+          encode2(object[key]);
+    };
+    const makeRoom = (end) => {
+      let newSize;
+      if (end > 16777216) {
+        if (end - start > MAX_BUFFER_SIZE)
+          throw new Error("Encoded buffer would be larger than maximum buffer size");
+        newSize = Math.min(
+          MAX_BUFFER_SIZE,
+          Math.round(Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096) * 4096
+        );
+      } else
+        newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
+      let newBuffer = new ByteArrayAllocate(newSize);
+      targetView = new DataView(newBuffer.buffer, 0, newSize);
+      if (target.copy)
+        target.copy(newBuffer, 0, start, end);
+      else
+        newBuffer.set(target.slice(start, end));
+      position -= start;
+      start = 0;
+      safeEnd = newBuffer.length - 10;
+      return target = newBuffer;
+    };
+    let chunkThreshold = 100;
+    let continuedChunkThreshold = 1e3;
+    this.encodeAsIterable = function(value, options2) {
+      return startEncoding(value, options2, encodeObjectAsIterable);
+    };
+    this.encodeAsAsyncIterable = function(value, options2) {
+      return startEncoding(value, options2, encodeObjectAsAsyncIterable);
+    };
+    function* encodeObjectAsIterable(object, iterateProperties, finalIterable) {
+      let constructor = object.constructor;
+      if (constructor === Object) {
+        let useRecords = encoder.useRecords !== false;
+        if (useRecords)
+          writeObject(object, true);
+        else
+          writeEntityLength(Object.keys(object).length, 160);
+        for (let key in object) {
+          let value = object[key];
+          if (!useRecords) encode2(key);
+          if (value && typeof value === "object") {
+            if (iterateProperties[key])
+              yield* encodeObjectAsIterable(value, iterateProperties[key]);
+            else
+              yield* tryEncode(value, iterateProperties, key);
+          } else encode2(value);
+        }
+      } else if (constructor === Array) {
+        let length = object.length;
+        writeArrayHeader(length);
+        for (let i = 0; i < length; i++) {
+          let value = object[i];
+          if (value && (typeof value === "object" || position - start > chunkThreshold)) {
+            if (iterateProperties.element)
+              yield* encodeObjectAsIterable(value, iterateProperties.element);
+            else
+              yield* tryEncode(value, iterateProperties, "element");
+          } else encode2(value);
+        }
+      } else if (object[Symbol.iterator] && !object.buffer) {
+        target[position++] = 159;
+        for (let value of object) {
+          if (value && (typeof value === "object" || position - start > chunkThreshold)) {
+            if (iterateProperties.element)
+              yield* encodeObjectAsIterable(value, iterateProperties.element);
+            else
+              yield* tryEncode(value, iterateProperties, "element");
+          } else encode2(value);
+        }
+        target[position++] = 255;
+      } else if (isBlob(object)) {
+        writeEntityLength(object.size, 64);
+        yield target.subarray(start, position);
+        yield object;
+        restartEncoding();
+      } else if (object[Symbol.asyncIterator]) {
+        target[position++] = 159;
+        yield target.subarray(start, position);
+        yield object;
+        restartEncoding();
+        target[position++] = 255;
+      } else {
+        encode2(object);
+      }
+      if (finalIterable && position > start) yield target.subarray(start, position);
+      else if (position - start > chunkThreshold) {
+        yield target.subarray(start, position);
+        restartEncoding();
+      }
+    }
+    function* tryEncode(value, iterateProperties, key) {
+      let restart = position - start;
+      try {
+        encode2(value);
+        if (position - start > chunkThreshold) {
+          yield target.subarray(start, position);
+          restartEncoding();
+        }
+      } catch (error) {
+        if (error.iteratorNotHandled) {
+          iterateProperties[key] = {};
+          position = start + restart;
+          yield* encodeObjectAsIterable.call(this, value, iterateProperties[key]);
+        } else throw error;
+      }
+    }
+    function restartEncoding() {
+      chunkThreshold = continuedChunkThreshold;
+      encoder.encode(null, THROW_ON_ITERABLE);
+    }
+    function startEncoding(value, options2, encodeIterable) {
+      if (options2 && options2.chunkThreshold)
+        chunkThreshold = continuedChunkThreshold = options2.chunkThreshold;
+      else
+        chunkThreshold = 100;
+      if (value && typeof value === "object") {
+        encoder.encode(null, THROW_ON_ITERABLE);
+        return encodeIterable(value, encoder.iterateProperties || (encoder.iterateProperties = {}), true);
+      }
+      return [encoder.encode(value)];
+    }
+    async function* encodeObjectAsAsyncIterable(value, iterateProperties) {
+      for (let encodedValue of encodeObjectAsIterable(value, iterateProperties, true)) {
+        let constructor = encodedValue.constructor;
+        if (constructor === ByteArray || constructor === Uint8Array)
+          yield encodedValue;
+        else if (isBlob(encodedValue)) {
+          let reader = encodedValue.stream().getReader();
+          let next;
+          while (!(next = await reader.read()).done) {
+            yield next.value;
+          }
+        } else if (encodedValue[Symbol.asyncIterator]) {
+          for await (let asyncValue of encodedValue) {
+            restartEncoding();
+            if (asyncValue)
+              yield* encodeObjectAsAsyncIterable(asyncValue, iterateProperties.async || (iterateProperties.async = {}));
+            else yield encoder.encode(asyncValue);
+          }
+        } else {
+          yield encodedValue;
+        }
+      }
+    }
+  }
+  useBuffer(buffer) {
+    target = buffer;
+    targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
+    position = 0;
+  }
+  clearSharedData() {
+    if (this.structures)
+      this.structures = [];
+    if (this.sharedValues)
+      this.sharedValues = void 0;
+  }
+  updateSharedData() {
+    let lastVersion = this.sharedVersion || 0;
+    this.sharedVersion = lastVersion + 1;
+    let structuresCopy = this.structures.slice(0);
+    let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion);
+    let saveResults = this.saveShared(
+      sharedData,
+      (existingShared) => (existingShared && existingShared.version || 0) == lastVersion
+    );
+    if (saveResults === false) {
+      sharedData = this.getShared() || {};
+      this.structures = sharedData.structures || [];
+      this.sharedValues = sharedData.packedValues;
+      this.sharedVersion = sharedData.version;
+      this.structures.nextId = this.structures.length;
+    } else {
+      structuresCopy.forEach((structure, i) => this.structures[i] = structure);
+    }
+    return saveResults;
+  }
+}
+function writeEntityLength(length, majorValue) {
+  if (length < 24)
+    target[position++] = majorValue | length;
+  else if (length < 256) {
+    target[position++] = majorValue | 24;
+    target[position++] = length;
+  } else if (length < 65536) {
+    target[position++] = majorValue | 25;
+    target[position++] = length >> 8;
+    target[position++] = length & 255;
+  } else {
+    target[position++] = majorValue | 26;
+    targetView.setUint32(position, length);
+    position += 4;
+  }
+}
+class SharedData {
+  constructor(structures, values, version) {
+    this.structures = structures;
+    this.packedValues = values;
+    this.version = version;
+  }
+}
+function writeArrayHeader(length) {
+  if (length < 24)
+    target[position++] = 128 | length;
+  else if (length < 256) {
+    target[position++] = 152;
+    target[position++] = length;
+  } else if (length < 65536) {
+    target[position++] = 153;
+    target[position++] = length >> 8;
+    target[position++] = length & 255;
+  } else {
+    target[position++] = 154;
+    targetView.setUint32(position, length);
+    position += 4;
+  }
+}
+const BlobConstructor = typeof Blob === "undefined" ? function() {
+} : Blob;
+function isBlob(object) {
+  if (object instanceof BlobConstructor)
+    return true;
+  let tag = object[Symbol.toStringTag];
+  return tag === "Blob" || tag === "File";
+}
+function findRepetitiveStrings(value, packedValues2) {
+  switch (typeof value) {
+    case "string":
+      if (value.length > 3) {
+        if (packedValues2.objectMap[value] > -1 || packedValues2.values.length >= packedValues2.maxValues)
+          return;
+        let packedStatus = packedValues2.get(value);
+        if (packedStatus) {
+          if (++packedStatus.count == 2) {
+            packedValues2.values.push(value);
+          }
+        } else {
+          packedValues2.set(value, {
+            count: 1
+          });
+          if (packedValues2.samplingPackedValues) {
+            let status = packedValues2.samplingPackedValues.get(value);
+            if (status)
+              status.count++;
+            else
+              packedValues2.samplingPackedValues.set(value, {
+                count: 1
+              });
+          }
+        }
+      }
+      break;
+    case "object":
+      if (value) {
+        if (value instanceof Array) {
+          for (let i = 0, l = value.length; i < l; i++) {
+            findRepetitiveStrings(value[i], packedValues2);
+          }
+        } else {
+          let includeKeys = !packedValues2.encoder.useRecords;
+          for (var key in value) {
+            if (value.hasOwnProperty(key)) {
+              if (includeKeys)
+                findRepetitiveStrings(key, packedValues2);
+              findRepetitiveStrings(value[key], packedValues2);
+            }
+          }
+        }
+      }
+      break;
+    case "function":
+      console.log(value);
+  }
+}
+const isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+extensionClasses = [
+  Date,
+  Set,
+  Error,
+  RegExp,
+  Tag,
+  ArrayBuffer,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  typeof BigUint64Array == "undefined" ? function() {
+  } : BigUint64Array,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  typeof BigInt64Array == "undefined" ? function() {
+  } : BigInt64Array,
+  Float32Array,
+  Float64Array,
+  SharedData
+];
+extensions = [
+  {
+    // Date
+    tag: 1,
+    encode(date, encode2) {
+      let seconds = date.getTime() / 1e3;
+      if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 4294967296) {
+        target[position++] = 26;
+        targetView.setUint32(position, seconds);
+        position += 4;
+      } else {
+        target[position++] = 251;
+        targetView.setFloat64(position, seconds);
+        position += 8;
+      }
+    }
+  },
+  {
+    // Set
+    tag: 258,
+    // https://github.com/input-output-hk/cbor-sets-spec/blob/master/CBOR_SETS.md
+    encode(set, encode2) {
+      let array = Array.from(set);
+      encode2(array);
+    }
+  },
+  {
+    // Error
+    tag: 27,
+    // http://cbor.schmorp.de/generic-object
+    encode(error, encode2) {
+      encode2([error.name, error.message]);
+    }
+  },
+  {
+    // RegExp
+    tag: 27,
+    // http://cbor.schmorp.de/generic-object
+    encode(regex, encode2) {
+      encode2(["RegExp", regex.source, regex.flags]);
+    }
+  },
+  {
+    // Tag
+    getTag(tag) {
+      return tag.tag;
+    },
+    encode(tag, encode2) {
+      encode2(tag.value);
+    }
+  },
+  {
+    // ArrayBuffer
+    encode(arrayBuffer, encode2, makeRoom) {
+      writeBuffer(arrayBuffer, makeRoom);
+    }
+  },
+  {
+    // Uint8Array
+    getTag(typedArray) {
+      if (typedArray.constructor === Uint8Array) {
+        if (this.tagUint8Array || hasNodeBuffer && this.tagUint8Array !== false)
+          return 64;
+      }
+    },
+    encode(typedArray, encode2, makeRoom) {
+      writeBuffer(typedArray, makeRoom);
+    }
+  },
+  typedArrayEncoder(68, 1),
+  typedArrayEncoder(69, 2),
+  typedArrayEncoder(70, 4),
+  typedArrayEncoder(71, 8),
+  typedArrayEncoder(72, 1),
+  typedArrayEncoder(77, 2),
+  typedArrayEncoder(78, 4),
+  typedArrayEncoder(79, 8),
+  typedArrayEncoder(85, 4),
+  typedArrayEncoder(86, 8),
+  {
+    encode(sharedData, encode2) {
+      let packedValues2 = sharedData.packedValues || [];
+      let sharedStructures = sharedData.structures || [];
+      if (packedValues2.values.length > 0) {
+        target[position++] = 216;
+        target[position++] = 51;
+        writeArrayHeader(4);
+        let valuesArray = packedValues2.values;
+        encode2(valuesArray);
+        writeArrayHeader(0);
+        writeArrayHeader(0);
+        packedObjectMap = Object.create(sharedPackedObjectMap || null);
+        for (let i = 0, l = valuesArray.length; i < l; i++) {
+          packedObjectMap[valuesArray[i]] = i;
+        }
+      }
+      if (sharedStructures) {
+        targetView.setUint32(position, 3655335424);
+        position += 3;
+        let definitions = sharedStructures.slice(0);
+        definitions.unshift(57344);
+        definitions.push(new Tag(sharedData.version, 1399353956));
+        encode2(definitions);
+      } else
+        encode2(new Tag(sharedData.version, 1399353956));
+    }
+  }
+];
+function typedArrayEncoder(tag, size) {
+  if (!isLittleEndianMachine && size > 1)
+    tag -= 4;
+  return {
+    tag,
+    encode: function writeExtBuffer(typedArray, encode2) {
+      let length = typedArray.byteLength;
+      let offset = typedArray.byteOffset || 0;
+      let buffer = typedArray.buffer || typedArray;
+      encode2(hasNodeBuffer ? Buffer$1.from(buffer, offset, length) : new Uint8Array(buffer, offset, length));
+    }
+  };
+}
+function writeBuffer(buffer, makeRoom) {
+  let length = buffer.byteLength;
+  if (length < 24) {
+    target[position++] = 64 + length;
+  } else if (length < 256) {
+    target[position++] = 88;
+    target[position++] = length;
+  } else if (length < 65536) {
+    target[position++] = 89;
+    target[position++] = length >> 8;
+    target[position++] = length & 255;
+  } else {
+    target[position++] = 90;
+    targetView.setUint32(position, length);
+    position += 4;
+  }
+  if (position + length >= target.length) {
+    makeRoom(position + length);
+  }
+  target.set(buffer.buffer ? buffer : new Uint8Array(buffer), position);
+  position += length;
+}
+function insertIds(serialized, idsToInsert) {
+  let nextId;
+  let distanceToMove = idsToInsert.length * 2;
+  let lastEnd = serialized.length - distanceToMove;
+  idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
+  for (let id = 0; id < idsToInsert.length; id++) {
+    let referee = idsToInsert[id];
+    referee.id = id;
+    for (let position2 of referee.references) {
+      serialized[position2++] = id >> 8;
+      serialized[position2] = id & 255;
+    }
+  }
+  while (nextId = idsToInsert.pop()) {
+    let offset = nextId.offset;
+    serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
+    distanceToMove -= 2;
+    let position2 = offset + distanceToMove;
+    serialized[position2++] = 216;
+    serialized[position2++] = 28;
+    lastEnd = offset;
+  }
+  return serialized;
+}
+function writeBundles(start, encode2) {
+  targetView.setUint32(bundledStrings.position + start, position - bundledStrings.position - start + 1);
+  let writeStrings = bundledStrings;
+  bundledStrings = null;
+  encode2(writeStrings[0]);
+  encode2(writeStrings[1]);
+}
+let defaultEncoder = new Encoder({ useRecords: false });
+const encode = defaultEncoder.encode;
+defaultEncoder.encodeAsIterable;
+defaultEncoder.encodeAsAsyncIterable;
+const REUSE_BUFFER_MODE = 512;
+const RESET_BUFFER_MODE = 1024;
+const THROW_ON_ITERABLE = 2048;
+function b64ToBytes(b64) {
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1)
+    out[i] = binary.charCodeAt(i);
+  return out;
+}
+class ServerPublicKeyCache {
+  constructor(collectorUrl, opts = {}, fetchImpl = (...args) => fetch(...args)) {
+    __publicField(this, "collectorUrl");
+    __publicField(this, "opts");
+    __publicField(this, "fetchImpl");
+    __publicField(this, "cached", null);
+    this.collectorUrl = collectorUrl;
+    this.opts = opts;
+    this.fetchImpl = fetchImpl;
+  }
+  async get() {
+    return (await this.getBundle()).key;
+  }
+  /** Back-compat: returns the X25519 key + alias only. */
+  async getWithAlias() {
+    const bundle = await this.getBundle();
+    return { key: bundle.key, aliasPath: bundle.aliasPath };
+  }
+  /**
+   * Fetch (or return cached) the full PK bundle: X25519 ingest key, the
+   * obfuscated alias path, and the optional Ed25519 result-signing public
+   * key. Integrators that verify sealed results should hold onto the
+   * `resultSigningKey` and pass it to `verifySealedResult()`.
+   */
+  async getBundle() {
+    const maxAge = this.opts.maxAgeMs ?? 6e4;
+    if (this.cached && Date.now() - this.cached.at < maxAge) {
+      return this.cached.bundle;
+    }
+    const res = await this.fetchImpl(`${this.collectorUrl.replace(/\/$/, "")}/v1/pk`, {
+      method: "GET",
+      credentials: "omit"
+    });
+    if (!res.ok) {
+      throw new Error(`fetch /v1/pk failed: ${res.status}`);
+    }
+    const body = await res.json();
+    const primary = body.keys.find((k) => k.id === body.primary) ?? body.keys[0];
+    if (!primary || primary.alg !== "x25519") {
+      throw new Error("no x25519 key advertised by collector");
+    }
+    const bundle = {
+      key: { id: primary.id, alg: "x25519", key: b64ToBytes(primary.key) },
+      aliasPath: body.aliasPath ?? null,
+      resultSigningKey: body.resultSigning && body.resultSigning.alg === "ed25519" ? b64ToBytes(body.resultSigning.key) : null
+    };
+    this.cached = { at: Date.now(), bundle };
+    return bundle;
+  }
+  clear() {
+    this.cached = null;
+  }
+}
+async function sendIngest(params) {
+  const base = params.collectorUrl.replace(/\/$/, "");
+  const url = params.aliasPath ? `${base}${params.aliasPath}?q=ingest` : `${base}/v1/ingest`;
+  if (params.preferBeacon && typeof navigator !== "undefined" && navigator.sendBeacon) {
+    const blob = new Blob([params.wire], {
+      type: "application/octet-stream"
+    });
+    const queued = navigator.sendBeacon(url, blob);
+    if (queued)
+      return null;
+  }
+  const fetchImpl = params.fetchImpl ?? ((...args) => fetch(...args));
+  const headers = {
+    "content-type": "application/octet-stream",
+    "x-k": params.serverKeyId,
+    "x-v": params.sdkVersion
+  };
+  if (params.projectKey)
+    headers["x-project-key"] = params.projectKey;
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers,
+    body: params.wire,
+    credentials: "include",
+    keepalive: true
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    const result = { status: res.status, body: text };
+    throw Object.assign(new Error(`/v1/ingest failed: ${res.status}`), { result });
+  }
+  return JSON.parse(text);
+}
+const WIRE_VERSION = 1;
+const EPH_PUB_LEN = 32;
+const NONCE_LEN = 12;
+const AES_KEY_LEN = 32;
+const HKDF_INFO = "fp-v1-ingest";
+const crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+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);
+}
+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);
+}
+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");
+}
+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);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+const hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+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;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  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 === void 0 || n2 === void 0) {
+      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;
+  }
+  return array;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+class Hash {
+}
+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 randomBytes$1(bytesLength = 32) {
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    return crypto.getRandomValues(new Uint8Array(bytesLength));
+  }
+  if (crypto && typeof crypto.randomBytes === "function") {
+    return Uint8Array.from(crypto.randomBytes(bytesLength));
+  }
+  throw new Error("crypto.getRandomValues must be defined");
+}
+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(4294967295);
+  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);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+class HashMD extends 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 = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    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);
+      if (take === blockLen) {
+        const dataView2 = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView2, 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) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    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();
+  }
+}
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+const SHA256_K = /* @__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
+]);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA256 extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = 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) {
+    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 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + 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;
+    }
+    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() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n$2 = /* @__PURE__ */ BigInt(0);
+const _1n$3 = /* @__PURE__ */ BigInt(1);
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return hex === "" ? _0n$2 : BigInt("0x" + hex);
+}
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
+}
+function bytesToNumberLE(bytes) {
+  abytes(bytes);
+  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+}
+function numberToBytesBE(n, len) {
+  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function ensureBytes(title, hex, expectedLength) {
+  let res;
+  if (typeof hex === "string") {
+    try {
+      res = hexToBytes(hex);
+    } catch (e) {
+      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+    }
+  } else if (isBytes(hex)) {
+    res = Uint8Array.from(hex);
+  } else {
+    throw new Error(title + " must be hex string or Uint8Array");
+  }
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+  return res;
+}
+const isPosBig = (n) => typeof n === "bigint" && _0n$2 <= n;
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+const bitMask = (n) => (_1n$3 << BigInt(n)) - _1n$3;
+function _validateObject(object, fields, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object[fieldName];
+    if (isOpt && val === void 0)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n$1 = BigInt(0), _1n$2 = BigInt(1), _2n$2 = /* @__PURE__ */ BigInt(2), _3n$1 = /* @__PURE__ */ BigInt(3);
+const _4n = /* @__PURE__ */ BigInt(4), _5n$1 = /* @__PURE__ */ BigInt(5), _7n = /* @__PURE__ */ BigInt(7);
+const _8n$1 = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n$1 ? result : b + result;
+}
+function pow2(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n$1) {
+    res *= res;
+    res %= modulo;
+  }
+  return res;
+}
+function invert(number, modulo) {
+  if (number === _0n$1)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n$1)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n$1, u = _1n$2;
+  while (a !== _0n$1) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    b = a, a = r, x = u, u = m;
+  }
+  const gcd = b;
+  if (gcd !== _1n$2)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
+}
+function assertIsSquare(Fp2, root, n) {
+  if (!Fp2.eql(Fp2.sqr(root), n))
+    throw new Error("Cannot find square root");
+}
+function sqrt3mod4(Fp2, n) {
+  const p1div4 = (Fp2.ORDER + _1n$2) / _4n;
+  const root = Fp2.pow(n, p1div4);
+  assertIsSquare(Fp2, root, n);
+  return root;
+}
+function sqrt5mod8(Fp2, n) {
+  const p5div8 = (Fp2.ORDER - _5n$1) / _8n$1;
+  const n2 = Fp2.mul(n, _2n$2);
+  const v = Fp2.pow(n2, p5div8);
+  const nv = Fp2.mul(n, v);
+  const i = Fp2.mul(Fp2.mul(nv, _2n$2), v);
+  const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
+  assertIsSquare(Fp2, root, n);
+  return root;
+}
+function sqrt9mod16(P) {
+  const Fp_ = Field(P);
+  const tn = tonelliShanks(P);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P + _7n) / _16n;
+  return (Fp2, n) => {
+    let tv1 = Fp2.pow(n, c4);
+    let tv2 = Fp2.mul(tv1, c1);
+    const tv3 = Fp2.mul(tv1, c2);
+    const tv4 = Fp2.mul(tv1, c3);
+    const e1 = Fp2.eql(Fp2.sqr(tv2), n);
+    const e2 = Fp2.eql(Fp2.sqr(tv3), n);
+    tv1 = Fp2.cmov(tv1, tv2, e1);
+    tv2 = Fp2.cmov(tv4, tv3, e2);
+    const e3 = Fp2.eql(Fp2.sqr(tv2), n);
+    const root = Fp2.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp2, root, n);
+    return root;
+  };
+}
+function tonelliShanks(P) {
+  if (P < _3n$1)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P - _1n$2;
+  let S = 0;
+  while (Q % _2n$2 === _0n$1) {
+    Q /= _2n$2;
+    S++;
+  }
+  let Z = _2n$2;
+  const _Fp = Field(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  }
+  if (S === 1)
+    return sqrt3mod4;
+  let cc = _Fp.pow(Z, Q);
+  const Q1div2 = (Q + _1n$2) / _2n$2;
+  return function tonelliSlow(Fp2, n) {
+    if (Fp2.is0(n))
+      return n;
+    if (FpLegendre(Fp2, n) !== 1)
+      throw new Error("Cannot find square root");
+    let M = S;
+    let c = Fp2.mul(Fp2.ONE, cc);
+    let t = Fp2.pow(n, Q);
+    let R = Fp2.pow(n, Q1div2);
+    while (!Fp2.eql(t, Fp2.ONE)) {
+      if (Fp2.is0(t))
+        return Fp2.ZERO;
+      let i = 1;
+      let t_tmp = Fp2.sqr(t);
+      while (!Fp2.eql(t_tmp, Fp2.ONE)) {
+        i++;
+        t_tmp = Fp2.sqr(t_tmp);
+        if (i === M)
+          throw new Error("Cannot find square root");
+      }
+      const exponent = _1n$2 << BigInt(M - i - 1);
+      const b = Fp2.pow(c, exponent);
+      M = i;
+      c = Fp2.sqr(b);
+      t = Fp2.mul(t, c);
+      R = Fp2.mul(R, b);
+    }
+    return R;
+  };
+}
+function FpSqrt(P) {
+  if (P % _4n === _3n$1)
+    return sqrt3mod4;
+  if (P % _8n$1 === _5n$1)
+    return sqrt5mod8;
+  if (P % _16n === _9n)
+    return sqrt9mod16(P);
+  return tonelliShanks(P);
+}
+function FpPow(Fp2, num, power) {
+  if (power < _0n$1)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (power === _0n$1)
+    return Fp2.ONE;
+  if (power === _1n$2)
+    return num;
+  let p = Fp2.ONE;
+  let d = num;
+  while (power > _0n$1) {
+    if (power & _1n$2)
+      p = Fp2.mul(p, d);
+    d = Fp2.sqr(d);
+    power >>= _1n$2;
+  }
+  return p;
+}
+function FpInvertBatch(Fp2, nums, passZero = false) {
+  const inverted = new Array(nums.length).fill(passZero ? Fp2.ZERO : void 0);
+  const multipliedAcc = nums.reduce((acc, num, i) => {
+    if (Fp2.is0(num))
+      return acc;
+    inverted[i] = acc;
+    return Fp2.mul(acc, num);
+  }, Fp2.ONE);
+  const invertedAcc = Fp2.inv(multipliedAcc);
+  nums.reduceRight((acc, num, i) => {
+    if (Fp2.is0(num))
+      return acc;
+    inverted[i] = Fp2.mul(acc, inverted[i]);
+    return Fp2.mul(acc, num);
+  }, invertedAcc);
+  return inverted;
+}
+function FpLegendre(Fp2, n) {
+  const p1mod2 = (Fp2.ORDER - _1n$2) / _2n$2;
+  const powered = Fp2.pow(n, p1mod2);
+  const yes = Fp2.eql(powered, Fp2.ONE);
+  const zero = Fp2.eql(powered, Fp2.ZERO);
+  const no = Fp2.eql(powered, Fp2.neg(Fp2.ONE));
+  if (!yes && !zero && !no)
+    throw new Error("invalid Legendre symbol result");
+  return yes ? 1 : zero ? 0 : -1;
+}
+function nLength(n, nBitLength) {
+  if (nBitLength !== void 0)
+    anumber(nBitLength);
+  const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+function Field(ORDER, bitLenOrOpts, isLE = false, opts = {}) {
+  if (ORDER <= _0n$1)
+    throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+  let _nbitLength = void 0;
+  let _sqrt = void 0;
+  let modFromBytes = false;
+  let allowedLengths = void 0;
+  if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
+    if (opts.sqrt || isLE)
+      throw new Error("cannot specify opts in two arguments");
+    const _opts = bitLenOrOpts;
+    if (_opts.BITS)
+      _nbitLength = _opts.BITS;
+    if (_opts.sqrt)
+      _sqrt = _opts.sqrt;
+    if (typeof _opts.isLE === "boolean")
+      isLE = _opts.isLE;
+    if (typeof _opts.modFromBytes === "boolean")
+      modFromBytes = _opts.modFromBytes;
+    allowedLengths = _opts.allowedLengths;
+  } else {
+    if (typeof bitLenOrOpts === "number")
+      _nbitLength = bitLenOrOpts;
+    if (opts.sqrt)
+      _sqrt = opts.sqrt;
+  }
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
+  if (BYTES > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let sqrtP;
+  const f = Object.freeze({
+    ORDER,
+    isLE,
+    BITS,
+    BYTES,
+    MASK: bitMask(BITS),
+    ZERO: _0n$1,
+    ONE: _1n$2,
+    allowedLengths,
+    create: (num) => mod(num, ORDER),
+    isValid: (num) => {
+      if (typeof num !== "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof num);
+      return _0n$1 <= num && num < ORDER;
+    },
+    is0: (num) => num === _0n$1,
+    // is valid and invertible
+    isValidNot0: (num) => !f.is0(num) && f.isValid(num),
+    isOdd: (num) => (num & _1n$2) === _1n$2,
+    neg: (num) => mod(-num, ORDER),
+    eql: (lhs, rhs) => lhs === rhs,
+    sqr: (num) => mod(num * num, ORDER),
+    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
+    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
+    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
+    pow: (num, power) => FpPow(f, num, power),
+    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+    // Same as above, but doesn't normalize
+    sqrN: (num) => num * num,
+    addN: (lhs, rhs) => lhs + rhs,
+    subN: (lhs, rhs) => lhs - rhs,
+    mulN: (lhs, rhs) => lhs * rhs,
+    inv: (num) => invert(num, ORDER),
+    sqrt: _sqrt || ((n) => {
+      if (!sqrtP)
+        sqrtP = FpSqrt(ORDER);
+      return sqrtP(f, n);
+    }),
+    toBytes: (num) => isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+    fromBytes: (bytes, skipValidation = true) => {
+      if (allowedLengths) {
+        if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+          throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length);
+        }
+        const padded = new Uint8Array(BYTES);
+        padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+        bytes = padded;
+      }
+      if (bytes.length !== BYTES)
+        throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
+      let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+      if (modFromBytes)
+        scalar = mod(scalar, ORDER);
+      if (!skipValidation) {
+        if (!f.isValid(scalar))
+          throw new Error("invalid field element: outside of range 0..ORDER");
+      }
+      return scalar;
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (lst) => FpInvertBatch(f, lst),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (a, b, c) => c ? b : a
+  });
+  return Object.freeze(f);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+BigInt(0);
+BigInt(1);
+BigInt(2);
+BigInt(8);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n = BigInt(0);
+const _1n$1 = BigInt(1);
+const _2n$1 = BigInt(2);
+function validateOpts(curve) {
+  _validateObject(curve, {
+    adjustScalarBytes: "function",
+    powPminus2: "function"
+  });
+  return Object.freeze({ ...curve });
+}
+function montgomery(curveDef) {
+  const CURVE = validateOpts(curveDef);
+  const { P, type, adjustScalarBytes: adjustScalarBytes2, powPminus2, randomBytes: rand } = CURVE;
+  const is25519 = type === "x25519";
+  if (!is25519 && type !== "x448")
+    throw new Error("invalid type");
+  const randomBytes_ = rand || randomBytes$1;
+  const montgomeryBits = is25519 ? 255 : 448;
+  const fieldLen = is25519 ? 32 : 56;
+  const Gu = is25519 ? BigInt(9) : BigInt(5);
+  const a24 = is25519 ? BigInt(121665) : BigInt(39081);
+  const minScalar = is25519 ? _2n$1 ** BigInt(254) : _2n$1 ** BigInt(447);
+  const maxAdded = is25519 ? BigInt(8) * _2n$1 ** BigInt(251) - _1n$1 : BigInt(4) * _2n$1 ** BigInt(445) - _1n$1;
+  const maxScalar = minScalar + maxAdded + _1n$1;
+  const modP = (n) => mod(n, P);
+  const GuBytes = encodeU(Gu);
+  function encodeU(u) {
+    return numberToBytesLE(modP(u), fieldLen);
+  }
+  function decodeU(u) {
+    const _u = ensureBytes("u coordinate", u, fieldLen);
+    if (is25519)
+      _u[31] &= 127;
+    return modP(bytesToNumberLE(_u));
+  }
+  function decodeScalar(scalar) {
+    return bytesToNumberLE(adjustScalarBytes2(ensureBytes("scalar", scalar, fieldLen)));
+  }
+  function scalarMult(scalar, u) {
+    const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
+    if (pu === _0n)
+      throw new Error("invalid private or public key received");
+    return encodeU(pu);
+  }
+  function scalarMultBase(scalar) {
+    return scalarMult(scalar, GuBytes);
+  }
+  function cswap(swap, x_2, x_3) {
+    const dummy = modP(swap * (x_2 - x_3));
+    x_2 = modP(x_2 - dummy);
+    x_3 = modP(x_3 + dummy);
+    return { x_2, x_3 };
+  }
+  function montgomeryLadder(u, scalar) {
+    aInRange("u", u, _0n, P);
+    aInRange("scalar", scalar, minScalar, maxScalar);
+    const k = scalar;
+    const x_1 = u;
+    let x_2 = _1n$1;
+    let z_2 = _0n;
+    let x_3 = u;
+    let z_3 = _1n$1;
+    let swap = _0n;
+    for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
+      const k_t = k >> t & _1n$1;
+      swap ^= k_t;
+      ({ x_2, x_3 } = cswap(swap, x_2, x_3));
+      ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+      swap = k_t;
+      const A = x_2 + z_2;
+      const AA = modP(A * A);
+      const B = x_2 - z_2;
+      const BB = modP(B * B);
+      const E = AA - BB;
+      const C = x_3 + z_3;
+      const D = x_3 - z_3;
+      const DA = modP(D * A);
+      const CB = modP(C * B);
+      const dacb = DA + CB;
+      const da_cb = DA - CB;
+      x_3 = modP(dacb * dacb);
+      z_3 = modP(x_1 * modP(da_cb * da_cb));
+      x_2 = modP(AA * BB);
+      z_2 = modP(E * (AA + modP(a24 * E)));
+    }
+    ({ x_2, x_3 } = cswap(swap, x_2, x_3));
+    ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+    const z2 = powPminus2(z_2);
+    return modP(x_2 * z2);
+  }
+  const lengths = {
+    secretKey: fieldLen,
+    publicKey: fieldLen,
+    seed: fieldLen
+  };
+  const randomSecretKey = (seed = randomBytes_(fieldLen)) => {
+    abytes(seed, lengths.seed);
+    return seed;
+  };
+  function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: scalarMultBase(secretKey) };
+  }
+  const utils = {
+    randomSecretKey,
+    randomPrivateKey: randomSecretKey
+  };
+  return {
+    keygen,
+    getSharedSecret: (secretKey, publicKey) => scalarMult(secretKey, publicKey),
+    getPublicKey: (secretKey) => scalarMultBase(secretKey),
+    scalarMult,
+    scalarMultBase,
+    utils,
+    GuBytes: GuBytes.slice(),
+    lengths
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);
+const _5n = BigInt(5), _8n = BigInt(8);
+const ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
+const ed25519_CURVE = /* @__PURE__ */ (() => ({
+  p: ed25519_CURVE_p,
+  n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+  h: _8n,
+  a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+  d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+  Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+  Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+}))();
+function ed25519_pow_2_252_3(x) {
+  const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+  const P = ed25519_CURVE_p;
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, _2n, P) * b2 % P;
+  const b5 = pow2(b4, _1n, P) * x % P;
+  const b10 = pow2(b5, _5n, P) * b5 % P;
+  const b20 = pow2(b10, _10n, P) * b10 % P;
+  const b40 = pow2(b20, _20n, P) * b20 % P;
+  const b80 = pow2(b40, _40n, P) * b40 % P;
+  const b160 = pow2(b80, _80n, P) * b80 % P;
+  const b240 = pow2(b160, _80n, P) * b80 % P;
+  const b250 = pow2(b240, _10n, P) * b10 % P;
+  const pow_p_5_8 = pow2(b250, _2n, P) * x % P;
+  return { pow_p_5_8, b2 };
+}
+function adjustScalarBytes(bytes) {
+  bytes[0] &= 248;
+  bytes[31] &= 127;
+  bytes[31] |= 64;
+  return bytes;
+}
+const Fp = /* @__PURE__ */ (() => Field(ed25519_CURVE.p, { isLE: true }))();
+const x25519 = /* @__PURE__ */ (() => {
+  const P = Fp.ORDER;
+  return montgomery({
+    P,
+    type: "x25519",
+    powPminus2: (x) => {
+      const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
+      return mod(pow2(pow_p_5_8, _3n, P) * b2, P);
+    },
+    adjustScalarBytes
+  });
+})();
+function generateKeypair() {
+  const privateKey = x25519.utils.randomPrivateKey();
+  const publicKey = x25519.getPublicKey(privateKey);
+  return { publicKey, privateKey };
+}
+function deriveSharedSecret(privateKey, peerPublicKey) {
+  return x25519.getSharedSecret(privateKey, peerPublicKey);
+}
+class HMAC extends Hash {
+  constructor(hash, _key) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    ahash(hash);
+    const key = toBytes(_key);
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf2) {
+    aexists(this);
+    this.iHash.update(buf2);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    abytes(out, this.outputLen);
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to || (to = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
+function extract(hash, ikm, salt) {
+  ahash(hash);
+  if (salt === void 0)
+    salt = new Uint8Array(hash.outputLen);
+  return hmac(hash, toBytes(salt), toBytes(ikm));
+}
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.from([0]);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+function expand(hash, prk, info, length = 32) {
+  ahash(hash);
+  anumber(length);
+  const olen = hash.outputLen;
+  if (length > 255 * olen)
+    throw new Error("Length should be <= 255*HashLen");
+  const blocks = Math.ceil(length / olen);
+  if (info === void 0)
+    info = EMPTY_BUFFER;
+  const okm = new Uint8Array(blocks * olen);
+  const HMAC2 = hmac.create(hash, prk);
+  const HMACTmp = HMAC2._cloneInto();
+  const T = new Uint8Array(HMAC2.outputLen);
+  for (let counter = 0; counter < blocks; counter++) {
+    HKDF_COUNTER[0] = counter + 1;
+    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T);
+    okm.set(T, olen * counter);
+    HMAC2._cloneInto(HMACTmp);
+  }
+  HMAC2.destroy();
+  HMACTmp.destroy();
+  clean(T, HKDF_COUNTER);
+  return okm.slice(0, length);
+}
+const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+const INFO_BYTES = new TextEncoder().encode(HKDF_INFO);
+const EMPTY_SALT = new Uint8Array(0);
+function deriveAesKey(sharedSecret, salt) {
+  return hkdf(sha256, sharedSecret, EMPTY_SALT, INFO_BYTES, AES_KEY_LEN);
+}
+function requireSubtle() {
+  const c = globalThis.crypto;
+  if (!c?.subtle) {
+    throw new Error("globalThis.crypto.subtle is unavailable in this runtime");
+  }
+  return c.subtle;
+}
+function buf(bytes) {
+  return bytes;
+}
+async function importKey(raw, usages) {
+  return requireSubtle().importKey("raw", buf(raw), { name: "AES-GCM" }, false, usages);
+}
+async function encryptGcm(key, nonce, plaintext) {
+  const ck = await importKey(key, ["encrypt"]);
+  const ct = await requireSubtle().encrypt({ name: "AES-GCM", iv: buf(nonce) }, ck, buf(plaintext));
+  return new Uint8Array(ct);
+}
+function randomBytes(length) {
+  const c = globalThis.crypto;
+  if (!c?.getRandomValues) {
+    throw new Error("globalThis.crypto.getRandomValues is unavailable");
+  }
+  return c.getRandomValues(new Uint8Array(length));
+}
+async function seal(serverPublicKey, plaintext) {
+  const eph = generateKeypair();
+  const shared = deriveSharedSecret(eph.privateKey, serverPublicKey);
+  const aesKey = deriveAesKey(shared);
+  const nonce = randomBytes(NONCE_LEN);
+  const ct = await encryptGcm(aesKey, nonce, plaintext);
+  const wire = new Uint8Array(1 + EPH_PUB_LEN + NONCE_LEN + ct.length);
+  wire[0] = WIRE_VERSION;
+  wire.set(eph.publicKey, 1);
+  wire.set(nonce, 1 + EPH_PUB_LEN);
+  wire.set(ct, 1 + EPH_PUB_LEN + NONCE_LEN);
+  return { wire, ephemeralPublicKey: eph.publicKey };
+}
+function collectHardware() {
+  const screen = Dimensions.get("screen");
+  const ratio = PixelRatio.get();
+  const osLabel = Platform.OS === "ios" ? "iOS" : Platform.OS === "android" ? "Android" : Platform.OS;
+  const userAgent = `${osLabel}/${Platform.Version}; RN`;
+  return {
+    userAgent,
+    platform: Platform.OS,
+    screen: {
+      width: Math.round(screen.width * ratio),
+      height: Math.round(screen.height * ratio)
+    },
+    devicePixelRatio: ratio
+  };
+}
+let localize = null;
+try {
+  localize = require("react-native-localize");
+} catch {
+  localize = null;
+}
+function collectIntl() {
+  const timezone = localize?.getTimeZone() ?? jsTimezone();
+  const languages = localize?.getLocales().map((l) => l.languageTag) ?? rnLanguages();
+  const language = languages[0];
+  return {
+    ...timezone !== void 0 ? { timezone } : {},
+    ...language !== void 0 ? { language } : {},
+    ...languages.length > 0 ? { languages } : {}
+  };
+}
+function jsTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return void 0;
+  }
+}
+function rnLanguages() {
+  if (Platform.OS === "ios") {
+    const settings = NativeModules.SettingsManager?.settings;
+    if (settings?.AppleLanguages?.length) return settings.AppleLanguages;
+    if (settings?.AppleLocale) return [settings.AppleLocale];
+  } else if (Platform.OS === "android") {
+    const locale = NativeModules.I18nManager?.localeIdentifier;
+    if (locale) return [locale];
+  }
+  return I18nManager.isRTL ? ["ar"] : [];
+}
+let netinfo = null;
+try {
+  netinfo = require("@react-native-community/netinfo");
+} catch {
+  netinfo = null;
+}
+async function collectNetwork() {
+  if (!netinfo) return void 0;
+  try {
+    const state = await netinfo.fetch();
+    const details = state.details ?? {};
+    const gen = typeof details.cellularGeneration === "string" ? details.cellularGeneration : void 0;
+    const effectiveType = gen ?? state.type;
+    const block = {};
+    if (effectiveType) block.effectiveType = effectiveType;
+    if (typeof details.isConnectionExpensive === "boolean") {
+      block.saveData = details.isConnectionExpensive;
+    }
+    return Object.keys(block).length ? block : void 0;
+  } catch {
+    return void 0;
+  }
+}
+const FP_RN_BRIDGE = NativeModules.FpRnModule;
+function isNativeLinked() {
+  return FP_RN_BRIDGE !== void 0;
+}
+async function collectNativeMobile() {
+  if (!FP_RN_BRIDGE) {
+    return {};
+  }
+  try {
+    return await FP_RN_BRIDGE.collect();
+  } catch {
+    return {};
+  }
+}
+async function collectSignals() {
+  const [network, native] = await Promise.all([collectNetwork(), collectNativeMobile()]);
+  const signals = {
+    hardware: collectHardware(),
+    intl: collectIntl()
+  };
+  if (network) signals.network = network;
+  const mobile = pickMobile(native);
+  if (mobile) signals.mobile = mobile;
+  return signals;
+}
+function pickMobile(p) {
+  const out = {};
+  if (p.os === "ios" || p.os === "android") out.os = p.os;
+  if (typeof p.osVersion === "string") out.osVersion = p.osVersion;
+  if (typeof p.model === "string") out.model = p.model;
+  if (typeof p.manufacturer === "string") out.manufacturer = p.manufacturer;
+  if (typeof p.idfv === "string") out.idfv = p.idfv;
+  if (typeof p.androidId === "string") out.androidId = p.androidId;
+  if (typeof p.installId === "string") out.installId = p.installId;
+  if (typeof p.totalMemoryMb === "number") out.totalMemoryMb = p.totalMemoryMb;
+  if (typeof p.isTablet === "boolean") out.isTablet = p.isTablet;
+  if (typeof p.bundleId === "string") out.bundleId = p.bundleId;
+  if (typeof p.appVersion === "string") out.appVersion = p.appVersion;
+  return Object.keys(out).length ? out : void 0;
+}
+let asyncStorage = null;
+try {
+  asyncStorage = require("@react-native-async-storage/async-storage").default;
+} catch {
+  asyncStorage = null;
+}
+const SESSION_KEY = "fp79.sessionId";
+function freshSessionId() {
+  const bytes = randomBytes(12);
+  let out = "sess-";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+let cached = null;
+let restoring = null;
+function getOrCreateSessionId() {
+  if (cached) return cached;
+  cached = freshSessionId();
+  if (asyncStorage) {
+    void asyncStorage.setItem(SESSION_KEY, cached);
+  }
+  return cached;
+}
+function restoreSessionId() {
+  if (!asyncStorage) return Promise.resolve();
+  if (!restoring) {
+    restoring = asyncStorage.getItem(SESSION_KEY).then((stored) => {
+      if (stored && !cached) cached = stored;
+    }).catch(() => {
+    });
+  }
+  return restoring;
+}
+const SDK_VERSION = "0.0.1";
+class FpRnClient {
+  constructor(config) {
+    __publicField(this, "pkCache");
+    __publicField(this, "config");
+    this.config = config;
+    this.pkCache = new ServerPublicKeyCache(config.collectorUrl);
+    void restoreSessionId();
+  }
+  /** Warm-up the public-key cache. FpProvider awaits this in useEffect
+   *  so the very first identify() call doesn't pay the /v1/pk hop and
+   *  so auth misconfig surfaces as ready=false up-front. */
+  async warmUp() {
+    await this.pkCache.getWithAlias();
+  }
+  async identify(opts = {}) {
+    const signals = await collectSignals();
+    const sessionId = getOrCreateSessionId();
+    const event = opts.event ?? "pageview";
+    const syncMode = opts.sync ?? true;
+    const payload = {
+      sdkVersion: SDK_VERSION,
+      ts: Date.now(),
+      sessionId,
+      // Mobile apps have no URL but the wire schema requires a string —
+      // use the bundle id (if collected via native) as a stable
+      // "namespace" so dashboard filters don't choke on every event
+      // sharing the same placeholder. Fall back to a sentinel scheme.
+      pageUrl: bundleAsUrl(signals.mobile?.bundleId) ?? "rn://app",
+      referrer: "",
+      event,
+      signals
+    };
+    if (opts.userId !== void 0) {
+      payload.accountHint = { userId: opts.userId };
+    }
+    if (syncMode) payload.sync = true;
+    const { key: serverKey, aliasPath } = await this.pkCache.getWithAlias();
+    const plaintext = new Uint8Array(encode(payload));
+    const { wire } = await seal(serverKey.key, plaintext);
+    return await sendIngest({
+      collectorUrl: this.config.collectorUrl,
+      wire,
+      serverKeyId: serverKey.id,
+      sdkVersion: SDK_VERSION,
+      preferBeacon: false,
+      ...aliasPath ? { aliasPath } : {},
+      projectKey: this.config.projectKey
+    });
+  }
+}
+function bundleAsUrl(bundleId) {
+  if (!bundleId) return void 0;
+  return `rn://${bundleId}`;
+}
+const FpContext = createContext({
+  instance: null,
+  ready: false,
+  error: null
+});
+function FpProvider({ config, children }) {
+  const instance = useMemo(() => new FpRnClient(config), [config.collectorUrl, config.projectKey]);
+  const [state, setState] = useState({
+    instance: null,
+    ready: false,
+    error: null
+  });
+  useEffect(() => {
+    let cancelled = false;
+    if (!isNativeLinked() && __DEV__) {
+      console.warn(
+        "[@fingerprint79/react-native] Native module not linked. Mobile signals (idfv / installId / hardware) will be absent. Did you run `pod install` (iOS) and rebuild (Android)?"
+      );
+    }
+    instance.warmUp().then(() => {
+      if (cancelled) return;
+      setState({ instance, ready: true, error: null });
+    }).catch((e) => {
+      if (cancelled) return;
+      setState({
+        instance: null,
+        ready: false,
+        error: e instanceof Error ? e : new Error(String(e))
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [instance]);
+  return /* @__PURE__ */ jsx(FpContext.Provider, { value: state, children });
+}
+function useFpContext() {
+  return useContext(FpContext);
+}
+function useFpStatus() {
+  const ctx = useFpContext();
+  return { ready: ctx.ready, error: ctx.error };
+}
+function useIdentify(defaults = {}) {
+  const ctx = useFpContext();
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const defaultEvent = defaults.event;
+  const defaultUserId = defaults.userId;
+  const defaultSync = defaults.sync;
+  const identify = useCallback(
+    async (opts) => {
+      if (!ctx.instance) {
+        const err = ctx.error ?? new Error("FpProvider not ready");
+        setError(err);
+        throw err;
+      }
+      const merged = {
+        ...defaultEvent !== void 0 ? { event: defaultEvent } : {},
+        ...defaultUserId !== void 0 ? { userId: defaultUserId } : {},
+        ...defaultSync !== void 0 ? { sync: defaultSync } : {},
+        ...opts ?? {}
+      };
+      setLoading(true);
+      setError(null);
+      try {
+        const r = await ctx.instance.identify(merged);
+        setData(r);
+        return r;
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [ctx.instance, ctx.error, defaultEvent, defaultUserId, defaultSync]
+  );
+  return { identify, data, loading, error };
+}
+function useAutoIdentify(opts = {}) {
+  const ctx = useFpContext();
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const event = opts.event ?? "pageview";
+  const userId = opts.userId;
+  const sync = opts.sync;
+  useEffect(() => {
+    if (!ctx.instance) return;
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void ctx.instance.identify({
+      event,
+      ...userId !== void 0 ? { userId } : {},
+      ...sync !== void 0 ? { sync } : {}
+    }).then(
+      (r) => {
+        if (cancelled) return;
+        setData(r);
+        setLoading(false);
+      },
+      (e) => {
+        if (cancelled) return;
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setLoading(false);
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [ctx.instance, event, userId, sync]);
+  return { data, loading, error };
+}
+export {
+  FpProvider,
+  FpRnClient,
+  useAutoIdentify,
+  useFpStatus,
+  useIdentify
+};
+//# sourceMappingURL=index.mjs.map