ranuts 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/src/utils/index.js

@@ -0,0 +1,4021 @@
+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 { o as isString, p as randomString } from "../../mimeType-eRf1TlBb.js";
+import { C, a, F, H, b, M, R, c, d, e, f, g, h, i, j, k, l, m, n, r, q, s, t, u, v, w } from "../../mimeType-eRf1TlBb.js";
+const sections = {
+  172351395: { name: "EBML", type: "Container" },
+  646: { name: "EBMLVersion", type: "Uint" },
+  759: { name: "EBMLReadVersion", type: "Uint" },
+  754: { name: "EBMLMaxIDLength", type: "Uint" },
+  755: { name: "EBMLMaxSizeLength", type: "Uint" },
+  642: { name: "DocType", type: "String" },
+  647: { name: "DocTypeVersion", type: "Uint" },
+  645: { name: "DocTypeReadVersion", type: "Uint" },
+  108: { name: "Void", type: "Binary" },
+  63: { name: "CRC-32", type: "Binary" },
+  190023271: { name: "SignatureSlot", type: "Container" },
+  16010: { name: "SignatureAlgo", type: "Uint" },
+  16026: { name: "SignatureHash", type: "Uint" },
+  16037: { name: "SignaturePublicKey", type: "Binary" },
+  16053: { name: "Signature", type: "Binary" },
+  15963: { name: "SignatureElements", type: "Container" },
+  15995: { name: "SignatureElementList", type: "Container" },
+  9522: { name: "SignedElement", type: "Binary" },
+  139690087: { name: "Segment", type: "Container" },
+  21863284: { name: "SeekHead", type: "Container" },
+  3515: { name: "Seek", type: "Container" },
+  5035: { name: "SeekID", type: "Binary" },
+  5036: { name: "SeekPosition", type: "Uint" },
+  88713574: { name: "Info", type: "Container" },
+  13220: { name: "SegmentUID", type: "Binary" },
+  13188: { name: "SegmentFilename", type: "String" },
+  1882403: { name: "PrevUID", type: "Binary" },
+  1868715: { name: "PrevFilename", type: "String" },
+  2013475: { name: "NextUID", type: "Binary" },
+  1999803: { name: "NextFilename", type: "String" },
+  1092: { name: "SegmentFamily", type: "Binary" },
+  10532: { name: "ChapterTranslate", type: "Container" },
+  10748: { name: "ChapterTranslateEditionUID", type: "Uint" },
+  10687: { name: "ChapterTranslateCodec", type: "Uint" },
+  10661: { name: "ChapterTranslateID", type: "Binary" },
+  710577: { name: "TimecodeScale", type: "Uint" },
+  1161: { name: "Duration", type: "Float" },
+  1121: { name: "DateUTC", type: "Date" },
+  15273: { name: "Title", type: "String" },
+  3456: { name: "MuxingApp", type: "String" },
+  5953: { name: "WritingApp", type: "String" },
+  // 0xf43b675: { name: 'Cluster', type: 'Container' },
+  103: { name: "Timecode", type: "Uint" },
+  6228: { name: "SilentTracks", type: "Container" },
+  6359: { name: "SilentTrackNumber", type: "Uint" },
+  39: { name: "Position", type: "Uint" },
+  43: { name: "PrevSize", type: "Uint" },
+  35: { name: "SimpleBlock", type: "Binary" },
+  32: { name: "BlockGroup", type: "Container" },
+  33: { name: "Block", type: "Binary" },
+  34: { name: "BlockVirtual", type: "Binary" },
+  13729: { name: "BlockAdditions", type: "Container" },
+  38: { name: "BlockMore", type: "Container" },
+  110: { name: "BlockAddID", type: "Uint" },
+  37: { name: "BlockAdditional", type: "Binary" },
+  27: { name: "BlockDuration", type: "Uint" },
+  122: { name: "ReferencePriority", type: "Uint" },
+  123: { name: "ReferenceBlock", type: "Int" },
+  125: { name: "ReferenceVirtual", type: "Int" },
+  36: { name: "CodecState", type: "Binary" },
+  13730: { name: "DiscardPadding", type: "Int" },
+  14: { name: "Slices", type: "Container" },
+  104: { name: "TimeSlice", type: "Container" },
+  76: { name: "LaceNumber", type: "Uint" },
+  77: { name: "FrameNumber", type: "Uint" },
+  75: { name: "BlockAdditionID", type: "Uint" },
+  78: { name: "Delay", type: "Uint" },
+  79: { name: "SliceDuration", type: "Uint" },
+  72: { name: "ReferenceFrame", type: "Container" },
+  73: { name: "ReferenceOffset", type: "Uint" },
+  74: { name: "ReferenceTimeCode", type: "Uint" },
+  47: { name: "EncryptedBlock", type: "Binary" },
+  106212971: { name: "Tracks", type: "Container" },
+  46: { name: "TrackEntry", type: "Container" },
+  87: { name: "TrackNumber", type: "Uint" },
+  13253: { name: "TrackUID", type: "Uint" },
+  3: { name: "TrackType", type: "Uint" },
+  57: { name: "FlagEnabled", type: "Uint" },
+  8: { name: "FlagDefault", type: "Uint" },
+  5546: { name: "FlagForced", type: "Uint" },
+  28: { name: "FlagLacing", type: "Uint" },
+  11751: { name: "MinCache", type: "Uint" },
+  11768: { name: "MaxCache", type: "Uint" },
+  254851: { name: "DefaultDuration", type: "Uint" },
+  216698: { name: "DefaultDecodedFieldDuration", type: "Uint" },
+  209231: { name: "TrackTimecodeScale", type: "Float" },
+  4991: { name: "TrackOffset", type: "Int" },
+  5614: { name: "MaxBlockAdditionID", type: "Uint" },
+  4974: { name: "Name", type: "String" },
+  177564: { name: "Language", type: "String" },
+  6: { name: "CodecID", type: "String" },
+  9122: { name: "CodecPrivate", type: "Binary" },
+  362120: { name: "CodecName", type: "String" },
+  13382: { name: "AttachmentLink", type: "Uint" },
+  1742487: { name: "CodecSettings", type: "String" },
+  1785920: { name: "CodecInfoURL", type: "String" },
+  438848: { name: "CodecDownloadURL", type: "String" },
+  42: { name: "CodecDecodeAll", type: "Uint" },
+  12203: { name: "TrackOverlay", type: "Uint" },
+  5802: { name: "CodecDelay", type: "Uint" },
+  5819: { name: "SeekPreRoll", type: "Uint" },
+  9764: { name: "TrackTranslate", type: "Container" },
+  9980: { name: "TrackTranslateEditionUID", type: "Uint" },
+  9919: { name: "TrackTranslateCodec", type: "Uint" },
+  9893: { name: "TrackTranslateTrackID", type: "Binary" },
+  96: { name: "Video", type: "Container" },
+  26: { name: "FlagInterlaced", type: "Uint" },
+  5048: { name: "StereoMode", type: "Uint" },
+  5056: { name: "AlphaMode", type: "Uint" },
+  5049: { name: "OldStereoMode", type: "Uint" },
+  48: { name: "PixelWidth", type: "Uint" },
+  58: { name: "PixelHeight", type: "Uint" },
+  5290: { name: "PixelCropBottom", type: "Uint" },
+  5307: { name: "PixelCropTop", type: "Uint" },
+  5324: { name: "PixelCropLeft", type: "Uint" },
+  5341: { name: "PixelCropRight", type: "Uint" },
+  5296: { name: "DisplayWidth", type: "Uint" },
+  5306: { name: "DisplayHeight", type: "Uint" },
+  5298: { name: "DisplayUnit", type: "Uint" },
+  5299: { name: "AspectRatioType", type: "Uint" },
+  963876: { name: "ColourSpace", type: "Binary" },
+  1029411: { name: "GammaValue", type: "Float" },
+  230371: { name: "FrameRate", type: "Float" },
+  97: { name: "Audio", type: "Container" },
+  53: { name: "SamplingFrequency", type: "Float" },
+  14517: { name: "OutputSamplingFrequency", type: "Float" },
+  31: { name: "Channels", type: "Uint" },
+  15739: { name: "ChannelPositions", type: "Binary" },
+  8804: { name: "BitDepth", type: "Uint" },
+  98: { name: "TrackOperation", type: "Container" },
+  99: { name: "TrackCombinePlanes", type: "Container" },
+  100: { name: "TrackPlane", type: "Container" },
+  101: { name: "TrackPlaneUID", type: "Uint" },
+  102: { name: "TrackPlaneType", type: "Uint" },
+  105: { name: "TrackJoinBlocks", type: "Container" },
+  109: { name: "TrackJoinUID", type: "Uint" },
+  64: { name: "TrickTrackUID", type: "Uint" },
+  65: { name: "TrickTrackSegmentUID", type: "Binary" },
+  70: { name: "TrickTrackFlag", type: "Uint" },
+  71: { name: "TrickMasterTrackUID", type: "Uint" },
+  68: { name: "TrickMasterTrackSegmentUID", type: "Binary" },
+  11648: { name: "ContentEncodings", type: "Container" },
+  8768: { name: "ContentEncoding", type: "Container" },
+  4145: { name: "ContentEncodingOrder", type: "Uint" },
+  4146: { name: "ContentEncodingScope", type: "Uint" },
+  4147: { name: "ContentEncodingType", type: "Uint" },
+  4148: { name: "ContentCompression", type: "Container" },
+  596: { name: "ContentCompAlgo", type: "Uint" },
+  597: { name: "ContentCompSettings", type: "Binary" },
+  4149: { name: "ContentEncryption", type: "Container" },
+  2017: { name: "ContentEncAlgo", type: "Uint" },
+  2018: { name: "ContentEncKeyID", type: "Binary" },
+  2019: { name: "ContentSignature", type: "Binary" },
+  2020: { name: "ContentSigKeyID", type: "Binary" },
+  2021: { name: "ContentSigAlgo", type: "Uint" },
+  2022: { name: "ContentSigHashAlgo", type: "Uint" },
+  206814059: { name: "Cues", type: "Container" },
+  59: { name: "CuePoint", type: "Container" },
+  51: { name: "CueTime", type: "Uint" },
+  55: { name: "CueTrackPositions", type: "Container" },
+  119: { name: "CueTrack", type: "Uint" },
+  113: { name: "CueClusterPosition", type: "Uint" },
+  112: { name: "CueRelativePosition", type: "Uint" },
+  50: { name: "CueDuration", type: "Uint" },
+  4984: { name: "CueBlockNumber", type: "Uint" },
+  106: { name: "CueCodecState", type: "Uint" },
+  91: { name: "CueReference", type: "Container" },
+  22: { name: "CueRefTime", type: "Uint" },
+  23: { name: "CueRefCluster", type: "Uint" },
+  4959: { name: "CueRefNumber", type: "Uint" },
+  107: { name: "CueRefCodecState", type: "Uint" },
+  155296873: { name: "Attachments", type: "Container" },
+  8615: { name: "AttachedFile", type: "Container" },
+  1662: { name: "FileDescription", type: "String" },
+  1646: { name: "FileName", type: "String" },
+  1632: { name: "FileMimeType", type: "String" },
+  1628: { name: "FileData", type: "Binary" },
+  1710: { name: "FileUID", type: "Uint" },
+  1653: { name: "FileReferral", type: "Binary" },
+  1633: { name: "FileUsedStartTime", type: "Uint" },
+  1634: { name: "FileUsedEndTime", type: "Uint" },
+  4433776: { name: "Chapters", type: "Container" },
+  1465: { name: "EditionEntry", type: "Container" },
+  1468: { name: "EditionUID", type: "Uint" },
+  1469: { name: "EditionFlagHidden", type: "Uint" },
+  1499: { name: "EditionFlagDefault", type: "Uint" },
+  1501: { name: "EditionFlagOrdered", type: "Uint" },
+  54: { name: "ChapterAtom", type: "Container" },
+  13252: { name: "ChapterUID", type: "Uint" },
+  5716: { name: "ChapterStringUID", type: "String" },
+  17: { name: "ChapterTimeStart", type: "Uint" },
+  18: { name: "ChapterTimeEnd", type: "Uint" },
+  24: { name: "ChapterFlagHidden", type: "Uint" },
+  1432: { name: "ChapterFlagEnabled", type: "Uint" },
+  11879: { name: "ChapterSegmentUID", type: "Binary" },
+  11964: { name: "ChapterSegmentEditionUID", type: "Uint" },
+  9155: { name: "ChapterPhysicalEquiv", type: "Uint" },
+  15: { name: "ChapterTrack", type: "Container" },
+  9: { name: "ChapterTrackNumber", type: "Uint" },
+  0: { name: "ChapterDisplay", type: "Container" },
+  5: { name: "ChapString", type: "String" },
+  892: { name: "ChapLanguage", type: "String" },
+  894: { name: "ChapCountry", type: "String" },
+  10564: { name: "ChapProcess", type: "Container" },
+  10581: { name: "ChapProcessCodecID", type: "Uint" },
+  1293: { name: "ChapProcessPrivate", type: "Binary" },
+  10513: { name: "ChapProcessCommand", type: "Container" },
+  10530: { name: "ChapProcessTime", type: "Uint" },
+  10547: { name: "ChapProcessData", type: "Binary" },
+  39109479: { name: "Tags", type: "Container" },
+  13171: { name: "Tag", type: "Container" },
+  9152: { name: "Targets", type: "Container" },
+  10442: { name: "TargetTypeValue", type: "Uint" },
+  9162: { name: "TargetType", type: "String" },
+  9157: { name: "TagTrackUID", type: "Uint" },
+  9161: { name: "TagEditionUID", type: "Uint" },
+  9156: { name: "TagChapterUID", type: "Uint" },
+  9158: { name: "TagAttachmentUID", type: "Uint" },
+  10184: { name: "SimpleTag", type: "Container" },
+  1443: { name: "TagName", type: "String" },
+  1146: { name: "TagLanguage", type: "String" },
+  1156: { name: "TagDefault", type: "Uint" },
+  1159: { name: "TagString", type: "String" },
+  1157: { name: "TagBinary", type: "Binary" }
+};
+class WebmBase {
+  constructor(name = "Unknown", type = "Unknown") {
+    __publicField(this, "source");
+    __publicField(this, "data");
+    this.name = name;
+    this.type = type;
+  }
+  updateBySource() {
+  }
+  setSource(source) {
+    this.source = source;
+    this.updateBySource();
+  }
+  updateByData() {
+  }
+  setData(data) {
+    this.data = data;
+    this.updateByData();
+  }
+}
+function padHex(hex) {
+  return hex.length % 2 === 1 ? "0" + hex : hex;
+}
+class WebmUint extends WebmBase {
+  constructor(name, type) {
+    super(name, type || "Uint");
+  }
+  updateBySource() {
+    this.data = "";
+    for (let i2 = 0; i2 < this.source.length; i2++) {
+      const hex = this.source[i2].toString(16);
+      this.data += padHex(hex);
+    }
+  }
+  updateByData() {
+    const length = this.data.length / 2;
+    this.source = new Uint8Array(length);
+    for (let i2 = 0; i2 < length; i2++) {
+      const hex = this.data.substr(i2 * 2, 2);
+      this.source[i2] = parseInt(hex, 16);
+    }
+  }
+  getValue() {
+    return parseInt(this.data, 16);
+  }
+  setValue(value) {
+    this.setData(padHex(value.toString(16)));
+  }
+}
+class WebmFloat extends WebmBase {
+  constructor(name, type) {
+    super(name, type || "Float");
+  }
+  getFloatArrayType() {
+    return this.source && this.source.length === 4 ? Float32Array : Float64Array;
+  }
+  updateBySource() {
+    const byteArray = this.source.reverse();
+    const floatArrayType = this.getFloatArrayType();
+    const floatArray = new floatArrayType(byteArray.buffer);
+    this.data = floatArray[0];
+  }
+  updateByData() {
+    const floatArrayType = this.getFloatArrayType();
+    const floatArray = new floatArrayType([this.data]);
+    const byteArray = new Uint8Array(floatArray.buffer);
+    this.source = byteArray.reverse();
+  }
+  getValue() {
+    return this.data;
+  }
+  setValue(value) {
+    this.setData(value);
+  }
+}
+class WebmContainer extends WebmBase {
+  constructor(name, type) {
+    super(name, type || "Container");
+    __publicField(this, "offset", 0);
+    __publicField(this, "data", []);
+  }
+  readByte() {
+    return this.source[this.offset++];
+  }
+  readUint() {
+    const firstByte = this.readByte();
+    const bytes = 8 - firstByte.toString(2).length;
+    let value = firstByte - (1 << 7 - bytes);
+    for (let i2 = 0; i2 < bytes; i2++) {
+      value *= 256;
+      value += this.readByte();
+    }
+    return value;
+  }
+  updateBySource() {
+    let end = void 0;
+    this.data = [];
+    for (this.offset = 0; this.offset < this.source.length; this.offset = end) {
+      const id = this.readUint();
+      const len = this.readUint();
+      end = Math.min(this.offset + len, this.source.length);
+      const data = this.source.slice(this.offset, end);
+      const info = sections[id] || { name: "Unknown", type: "Unknown" };
+      let ctr = WebmBase;
+      switch (info.type) {
+        case "Container":
+          ctr = WebmContainer;
+          break;
+        case "Uint":
+          ctr = WebmUint;
+          break;
+        case "Float":
+          ctr = WebmFloat;
+          break;
+      }
+      const section = new ctr(info.name, info.type);
+      section.setSource(data);
+      this.data.push({
+        id,
+        idHex: id.toString(16),
+        data: section
+      });
+    }
+  }
+  writeUint(x, draft = false) {
+    let bytes = 1, flag = 128;
+    while (x >= flag && bytes < 8) {
+      bytes++, flag *= 128;
+    }
+    if (!draft) {
+      let value = flag + x;
+      for (let i2 = bytes - 1; i2 >= 0; i2--) {
+        const c2 = value % 256;
+        this.source[this.offset + i2] = c2;
+        value = (value - c2) / 256;
+      }
+    }
+    this.offset += bytes;
+  }
+  writeSections(draft = false) {
+    this.offset = 0;
+    for (let i2 = 0; i2 < this.data.length; i2++) {
+      const section = this.data[i2], content = section.data.source, contentLength = content.length;
+      this.writeUint(section.id, draft);
+      this.writeUint(contentLength, draft);
+      if (!draft) {
+        this.source.set(content, this.offset);
+      }
+      this.offset += contentLength;
+    }
+    return this.offset;
+  }
+  updateByData() {
+    const length = this.writeSections(true);
+    this.source = new Uint8Array(length);
+    this.writeSections();
+  }
+  getSectionById(id) {
+    for (let i2 = 0; i2 < this.data.length; i2++) {
+      const section = this.data[i2];
+      if (section.id === id) {
+        return section.data;
+      }
+    }
+    return void 0;
+  }
+}
+class WebmFile extends WebmContainer {
+  constructor(source) {
+    super("File", "File");
+    this.setSource(source);
+  }
+  fixDuration(duration) {
+    const segmentSection = this.getSectionById(139690087);
+    if (!segmentSection) {
+      return false;
+    }
+    const infoSection = segmentSection.getSectionById(88713574);
+    if (!infoSection) {
+      return false;
+    }
+    const timeScaleSection = infoSection.getSectionById(710577);
+    if (!timeScaleSection) {
+      return false;
+    }
+    let durationSection = infoSection.getSectionById(1161);
+    if (durationSection) {
+      if (durationSection.getValue() <= 0) {
+        durationSection.setValue(duration);
+      } else {
+        return false;
+      }
+    } else {
+      durationSection = new WebmFloat("Duration", "Float");
+      durationSection.setValue(duration);
+      infoSection.data.push({
+        id: 1161,
+        data: durationSection
+      });
+    }
+    timeScaleSection.setValue(1e6);
+    infoSection.updateByData();
+    segmentSection.updateByData();
+    this.updateByData();
+    return true;
+  }
+  toBlob(type = "video/webm") {
+    return new Blob([this.source.buffer], { type });
+  }
+}
+const webmFixDuration = (blob, duration, type = "video/webm") => {
+  return new Promise((resolve, reject) => {
+    try {
+      const reader = new FileReader();
+      reader.addEventListener("loadend", () => {
+        try {
+          const result = reader.result;
+          const file = new WebmFile(new Uint8Array(result));
+          if (file.fixDuration(duration)) {
+            resolve(file.toBlob(type));
+          } else {
+            resolve(blob);
+          }
+        } catch (ex) {
+          reject(ex);
+        }
+      });
+      reader.addEventListener("error", () => reject());
+      reader.readAsArrayBuffer(blob);
+    } catch (ex) {
+      reject(ex);
+    }
+  });
+};
+function getMimeType() {
+  const types = ["audio/webm", "audio/mp4", "audio/ogg", "audio/wav", "audio/aac"];
+  for (let i2 = 0; i2 < types.length; i2++) {
+    if (MediaRecorder.isTypeSupported(types[i2])) {
+      return types[i2];
+    }
+  }
+  return void 0;
+}
+class AudioRecorder {
+  constructor() {
+    __publicField(this, "startTime");
+    __publicField(this, "chunks");
+    __publicField(this, "mediaRecorder");
+    __publicField(this, "blob");
+    this.startTime = Date.now();
+    this.chunks = [];
+    navigator.mediaDevices.getUserMedia({
+      audio: true
+    }).then((stream) => {
+      this.init(stream);
+    }).catch((error) => {
+    });
+  }
+  init(stream) {
+    var _a, _b;
+    const mimeType = getMimeType();
+    this.mediaRecorder = new MediaRecorder(stream, {
+      mimeType
+    });
+    (_a = this.mediaRecorder) == null ? void 0 : _a.addEventListener("dataavailable", async (event) => {
+      var _a2;
+      if (event.data.size > 0) {
+        this.chunks.push(event.data);
+      }
+      if (((_a2 = this.mediaRecorder) == null ? void 0 : _a2.state) === "inactive") {
+        const duration = Date.now() - this.startTime;
+        this.blob = new Blob(this.chunks, { type: mimeType });
+        if (mimeType === "audio/webm") {
+          this.blob = await webmFixDuration(this.blob, duration, this.blob.type);
+        }
+        this.chunks = [];
+      }
+    });
+    (_b = this.mediaRecorder) == null ? void 0 : _b.start();
+  }
+  start() {
+    var _a;
+    if (((_a = this.mediaRecorder) == null ? void 0 : _a.state) === "paused") {
+      this.mediaRecorder.resume();
+    }
+    return this.mediaRecorder;
+  }
+  pause() {
+    var _a;
+    if (((_a = this.mediaRecorder) == null ? void 0 : _a.state) === "recording") {
+      this.mediaRecorder.pause();
+    }
+    return this.mediaRecorder;
+  }
+  stop() {
+    var _a;
+    (_a = this.mediaRecorder) == null ? void 0 : _a.stop();
+    return this.blob;
+  }
+}
+const noop = () => {
+};
+var DEVICE = /* @__PURE__ */ ((DEVICE2) => {
+  DEVICE2["IPAD"] = "ipad";
+  DEVICE2["ANDROID"] = "android";
+  DEVICE2["IPhONE"] = "iphone";
+  DEVICE2["PC"] = "pc";
+  return DEVICE2;
+})(DEVICE || {});
+const currentDevice = () => {
+  if (typeof window !== "undefined") {
+    const ua = navigator.userAgent.toLowerCase();
+    if (/ipad|ipod/.test(ua)) return "ipad";
+    if (/android/.test(ua)) return "android";
+    if (/iphone/.test(ua)) return "iphone";
+    return "pc";
+  }
+  return "pc";
+};
+const isClient = typeof window !== "undefined";
+const isWeiXin = () => {
+  if (isClient) {
+    const ua = window.navigator.userAgent.toLowerCase();
+    return ua.includes("micromessenger");
+  }
+  return false;
+};
+const isMobile = () => {
+  if (!isClient) return false;
+  const ua = window.navigator.userAgent;
+  if (/Android|webOS|iPhone|iPod|iPad|BlackBerry/i.test(ua)) {
+    return true;
+  }
+  return false;
+};
+const isBangDevice = () => {
+  if (!isClient) return false;
+  const iphone = /iphone/i.test(window.navigator.userAgent);
+  const ratio2 = window.devicePixelRatio && window.devicePixelRatio === 2;
+  const ratio3 = window.devicePixelRatio && window.devicePixelRatio === 3;
+  const mini12 = window.screen.width === 360 && window.screen.height === 780;
+  const pro11 = window.screen.width === 375 && window.screen.height === 812;
+  const pro12 = window.screen.width === 390 && window.screen.height === 844;
+  const promax11 = window.screen.width === 414 && window.screen.height === 896;
+  const promax12 = window.screen.width === 428 && window.screen.height === 926;
+  switch (true) {
+    case (iphone && ratio3 && mini12):
+    case (iphone && ratio3 && pro11):
+    case (iphone && ratio3 && pro12):
+    case (iphone && ratio2 && promax11):
+    case (iphone && ratio3 && promax11):
+    case (iphone && ratio3 && promax12):
+      return true;
+    default:
+      return false;
+  }
+};
+const handleClick = (hooks = noop) => {
+  if (typeof document !== "undefined") {
+    document.addEventListener(
+      "click",
+      function(event) {
+        hooks(event);
+      },
+      true
+    );
+  }
+};
+const webglVendor = () => {
+  const glCanvas = document.createElement("canvas");
+  const gl = glCanvas.getContext("webgl2");
+  function getHardwareInfo(gl2) {
+    const debugInfo = gl2.getExtension("WEBGL_debug_renderer_info");
+    if (!debugInfo) {
+      return null;
+    }
+    const vendor = gl2.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+    const renderer = gl2.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    return {
+      vendor,
+      renderer
+    };
+  }
+  if (gl) {
+    return getHardwareInfo(gl);
+  }
+  return null;
+};
+const canvasVendor = () => {
+  const outScreenCanvas = document.createElement("canvas");
+  const ctx = outScreenCanvas.getContext("2d");
+  const txt = "BrowserLeaks,com <canvas> 1.0";
+  if (!ctx) return null;
+  ctx.textBaseline = "top";
+  ctx.font = "14px 'Arial'";
+  ctx.textBaseline = "alphabetic";
+  ctx.fillStyle = "#f60";
+  ctx.fillRect(125, 1, 62, 20);
+  ctx.fillStyle = "#069";
+  ctx.fillText(txt, 2, 15);
+  ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+  ctx.fillText(txt, 4, 17);
+  const canvasImageData = outScreenCanvas.toDataURL();
+  return canvasImageData;
+};
+const audioVendor = () => {
+  return new Promise((resolve, reject) => {
+    if (!isClient) reject("window is undefined");
+    const each = function(obj, iterator) {
+      if (Array.prototype.forEach && obj.forEach === Array.prototype.forEach) {
+        obj.forEach(iterator);
+      } else if (obj.length === +obj.length) {
+        for (let i2 = 0, l2 = obj.length; i2 < l2; i2++) {
+          iterator(obj[i2], i2, obj);
+        }
+      } else {
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            iterator(obj[key], Number(key), obj);
+          }
+        }
+      }
+    };
+    const AudioContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+    const context = new AudioContext(1, 44100, 44100);
+    const oscillator = context.createOscillator();
+    oscillator.type = "triangle";
+    oscillator.frequency.setValueAtTime(1e4, context.currentTime);
+    const compressor = context.createDynamicsCompressor();
+    each(
+      [
+        ["threshold", -50],
+        ["knee", 40],
+        ["ratio", 12],
+        ["reduction", -20],
+        ["attack", 0],
+        ["release", 0.25]
+      ],
+      function(item) {
+        if (compressor[item[0]] && typeof compressor[item[0]] !== "number") {
+          const { setValueAtTime } = compressor[item[0]];
+          setValueAtTime(item[1], context.currentTime);
+        }
+      }
+    );
+    oscillator.connect(compressor);
+    compressor.connect(context.destination);
+    oscillator.start(0);
+    context.startRendering();
+    const audioTimeoutId = setTimeout(function() {
+      context.oncomplete = () => {
+      };
+      reject("audioTimeout");
+      return "audioTimeout";
+    }, 100);
+    context.oncomplete = (event) => {
+      try {
+        clearTimeout(audioTimeoutId);
+        const result = event.renderedBuffer.getChannelData(0).slice(4500, 5e3).reduce(function(acc, val) {
+          return acc + Math.abs(val);
+        }, 0).toString();
+        oscillator.disconnect();
+        compressor.disconnect();
+        resolve(result);
+        return result;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+    };
+  });
+};
+const b64Tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const arraybuffer_error = "ARRAYBUFFER not supported by this environment";
+const uint8array_error = "UINT8ARRAY not supported by this environment";
+function str2packed(str, utfType, existingPacked, existingPackedLen, bigEndianMod) {
+  let codePnt, codePntArr, byteCnt = 0, i2, j2, intOffset, byteOffset, shiftModifier, transposeBytes;
+  existingPackedLen = existingPackedLen || 0;
+  const packed = existingPacked || [0], existingByteLen = existingPackedLen >>> 3;
+  if ("UTF8" === utfType) {
+    shiftModifier = bigEndianMod === -1 ? 3 : 0;
+    for (i2 = 0; i2 < str.length; i2 += 1) {
+      codePnt = str.charCodeAt(i2);
+      codePntArr = [];
+      if (128 > codePnt) {
+        codePntArr.push(codePnt);
+      } else if (2048 > codePnt) {
+        codePntArr.push(192 | codePnt >>> 6);
+        codePntArr.push(128 | codePnt & 63);
+      } else if (55296 > codePnt || 57344 <= codePnt) {
+        codePntArr.push(224 | codePnt >>> 12, 128 | codePnt >>> 6 & 63, 128 | codePnt & 63);
+      } else {
+        i2 += 1;
+        codePnt = 65536 + ((codePnt & 1023) << 10 | str.charCodeAt(i2) & 1023);
+        codePntArr.push(
+          240 | codePnt >>> 18,
+          128 | codePnt >>> 12 & 63,
+          128 | codePnt >>> 6 & 63,
+          128 | codePnt & 63
+        );
+      }
+      for (j2 = 0; j2 < codePntArr.length; j2 += 1) {
+        byteOffset = byteCnt + existingByteLen;
+        intOffset = byteOffset >>> 2;
+        while (packed.length <= intOffset) {
+          packed.push(0);
+        }
+        packed[intOffset] |= codePntArr[j2] << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+        byteCnt += 1;
+      }
+    }
+  } else {
+    shiftModifier = bigEndianMod === -1 ? 2 : 0;
+    transposeBytes = "UTF16LE" === utfType && bigEndianMod !== 1 || "UTF16LE" !== utfType && bigEndianMod === 1;
+    for (i2 = 0; i2 < str.length; i2 += 1) {
+      codePnt = str.charCodeAt(i2);
+      if (transposeBytes === true) {
+        j2 = codePnt & 255;
+        codePnt = j2 << 8 | codePnt >>> 8;
+      }
+      byteOffset = byteCnt + existingByteLen;
+      intOffset = byteOffset >>> 2;
+      while (packed.length <= intOffset) {
+        packed.push(0);
+      }
+      packed[intOffset] |= codePnt << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+      byteCnt += 2;
+    }
+  }
+  return { value: packed, binLen: byteCnt * 8 + existingPackedLen };
+}
+function hex2packed(str, existingPacked, existingPackedLen, bigEndianMod) {
+  let i2, num, intOffset, byteOffset;
+  if (0 !== str.length % 2) {
+    throw new Error("String of HEX type must be in byte increments");
+  }
+  existingPackedLen = existingPackedLen || 0;
+  const packed = existingPacked || [0], existingByteLen = existingPackedLen >>> 3, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < str.length; i2 += 2) {
+    num = parseInt(str.substr(i2, 2), 16);
+    if (!isNaN(num)) {
+      byteOffset = (i2 >>> 1) + existingByteLen;
+      intOffset = byteOffset >>> 2;
+      while (packed.length <= intOffset) {
+        packed.push(0);
+      }
+      packed[intOffset] |= num << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+    } else {
+      throw new Error("String of HEX type contains invalid characters");
+    }
+  }
+  return { value: packed, binLen: str.length * 4 + existingPackedLen };
+}
+function bytes2packed(str, existingPacked, existingPackedLen, bigEndianMod) {
+  let codePnt, i2, intOffset, byteOffset;
+  existingPackedLen = existingPackedLen || 0;
+  const packed = existingPacked || [0], existingByteLen = existingPackedLen >>> 3, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < str.length; i2 += 1) {
+    codePnt = str.charCodeAt(i2);
+    byteOffset = i2 + existingByteLen;
+    intOffset = byteOffset >>> 2;
+    if (packed.length <= intOffset) {
+      packed.push(0);
+    }
+    packed[intOffset] |= codePnt << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+  }
+  return { value: packed, binLen: str.length * 8 + existingPackedLen };
+}
+function b642packed(str, existingPacked, existingPackedLen, bigEndianMod) {
+  let byteCnt = 0, index, i2, j2, tmpInt, strPart, intOffset, byteOffset;
+  existingPackedLen = existingPackedLen || 0;
+  const packed = existingPacked || [0], existingByteLen = existingPackedLen >>> 3, shiftModifier = bigEndianMod === -1 ? 3 : 0, firstEqual = str.indexOf("=");
+  if (-1 === str.search(/^[a-z\d=+/]+$/i)) {
+    throw new Error("Invalid character in base-64 string");
+  }
+  str = str.replace(/=/g, "");
+  if (-1 !== firstEqual && firstEqual < str.length) {
+    throw new Error("Invalid '=' found in base-64 string");
+  }
+  for (i2 = 0; i2 < str.length; i2 += 4) {
+    strPart = str.substr(i2, 4);
+    tmpInt = 0;
+    for (j2 = 0; j2 < strPart.length; j2 += 1) {
+      index = b64Tab.indexOf(strPart.charAt(j2));
+      tmpInt |= index << 18 - 6 * j2;
+    }
+    for (j2 = 0; j2 < strPart.length - 1; j2 += 1) {
+      byteOffset = byteCnt + existingByteLen;
+      intOffset = byteOffset >>> 2;
+      while (packed.length <= intOffset) {
+        packed.push(0);
+      }
+      packed[intOffset] |= (tmpInt >>> 16 - j2 * 8 & 255) << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+      byteCnt += 1;
+    }
+  }
+  return { value: packed, binLen: byteCnt * 8 + existingPackedLen };
+}
+function uint8array2packed(arr, existingPacked, existingPackedLen, bigEndianMod) {
+  let i2, intOffset, byteOffset;
+  existingPackedLen = existingPackedLen || 0;
+  const packed = existingPacked || [0], existingByteLen = existingPackedLen >>> 3, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < arr.length; i2 += 1) {
+    byteOffset = i2 + existingByteLen;
+    intOffset = byteOffset >>> 2;
+    if (packed.length <= intOffset) {
+      packed.push(0);
+    }
+    packed[intOffset] |= arr[i2] << 8 * (shiftModifier + bigEndianMod * (byteOffset % 4));
+  }
+  return { value: packed, binLen: arr.length * 8 + existingPackedLen };
+}
+function arraybuffer2packed(arr, existingPacked, existingPackedLen, bigEndianMod) {
+  return uint8array2packed(new Uint8Array(arr), existingPacked, existingPackedLen, bigEndianMod);
+}
+function getStrConverter(format, utfType, bigEndianMod) {
+  switch (utfType) {
+    case "UTF8":
+    case "UTF16BE":
+    case "UTF16LE":
+      break;
+    default:
+      throw new Error("encoding must be UTF8, UTF16BE, or UTF16LE");
+  }
+  switch (format) {
+    case "HEX":
+      return function(str, existingBin, existingBinLen) {
+        return hex2packed(str, existingBin, existingBinLen, bigEndianMod);
+      };
+    case "TEXT":
+      return function(str, existingBin, existingBinLen) {
+        return str2packed(str, utfType, existingBin, existingBinLen, bigEndianMod);
+      };
+    case "B64":
+      return function(str, existingBin, existingBinLen) {
+        return b642packed(str, existingBin, existingBinLen, bigEndianMod);
+      };
+    case "BYTES":
+      return function(str, existingBin, existingBinLen) {
+        return bytes2packed(str, existingBin, existingBinLen, bigEndianMod);
+      };
+    case "ARRAYBUFFER":
+      try {
+        new ArrayBuffer(0);
+      } catch (ignore) {
+        throw new Error(arraybuffer_error);
+      }
+      return function(arr, existingBin, existingBinLen) {
+        return arraybuffer2packed(arr, existingBin, existingBinLen, bigEndianMod);
+      };
+    case "UINT8ARRAY":
+      try {
+        new Uint8Array(0);
+      } catch (ignore) {
+        throw new Error(uint8array_error);
+      }
+      return function(arr, existingBin, existingBinLen) {
+        return uint8array2packed(arr, existingBin, existingBinLen, bigEndianMod);
+      };
+    default:
+      throw new Error("format must be HEX, TEXT, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY");
+  }
+}
+function packed2hex(packed, outputLength, bigEndianMod, formatOpts) {
+  const hex_tab = "0123456789abcdef";
+  let str = "", i2, srcByte;
+  const length = outputLength / 8, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < length; i2 += 1) {
+    srcByte = packed[i2 >>> 2] >>> 8 * (shiftModifier + bigEndianMod * (i2 % 4));
+    str += hex_tab.charAt(srcByte >>> 4 & 15) + hex_tab.charAt(srcByte & 15);
+  }
+  return formatOpts["outputUpper"] ? str.toUpperCase() : str;
+}
+function packed2b64(packed, outputLength, bigEndianMod, formatOpts) {
+  let str = "", i2, j2, triplet, int1, int2;
+  const length = outputLength / 8, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < length; i2 += 3) {
+    int1 = i2 + 1 < length ? packed[i2 + 1 >>> 2] : 0;
+    int2 = i2 + 2 < length ? packed[i2 + 2 >>> 2] : 0;
+    triplet = (packed[i2 >>> 2] >>> 8 * (shiftModifier + bigEndianMod * (i2 % 4)) & 255) << 16 | (int1 >>> 8 * (shiftModifier + bigEndianMod * ((i2 + 1) % 4)) & 255) << 8 | int2 >>> 8 * (shiftModifier + bigEndianMod * ((i2 + 2) % 4)) & 255;
+    for (j2 = 0; j2 < 4; j2 += 1) {
+      if (i2 * 8 + j2 * 6 <= outputLength) {
+        str += b64Tab.charAt(triplet >>> 6 * (3 - j2) & 63);
+      } else {
+        str += formatOpts["b64Pad"];
+      }
+    }
+  }
+  return str;
+}
+function packed2bytes(packed, outputLength, bigEndianMod) {
+  let str = "", i2, srcByte;
+  const length = outputLength / 8, shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < length; i2 += 1) {
+    srcByte = packed[i2 >>> 2] >>> 8 * (shiftModifier + bigEndianMod * (i2 % 4)) & 255;
+    str += String.fromCharCode(srcByte);
+  }
+  return str;
+}
+function packed2arraybuffer(packed, outputLength, bigEndianMod) {
+  let i2;
+  const length = outputLength / 8, retVal = new ArrayBuffer(length), arrView = new Uint8Array(retVal), shiftModifier = bigEndianMod === -1 ? 3 : 0;
+  for (i2 = 0; i2 < length; i2 += 1) {
+    arrView[i2] = packed[i2 >>> 2] >>> 8 * (shiftModifier + bigEndianMod * (i2 % 4)) & 255;
+  }
+  return retVal;
+}
+function packed2uint8array(packed, outputLength, bigEndianMod) {
+  let i2;
+  const length = outputLength / 8, shiftModifier = bigEndianMod === -1 ? 3 : 0, retVal = new Uint8Array(length);
+  for (i2 = 0; i2 < length; i2 += 1) {
+    retVal[i2] = packed[i2 >>> 2] >>> 8 * (shiftModifier + bigEndianMod * (i2 % 4)) & 255;
+  }
+  return retVal;
+}
+function getOutputConverter(format, outputBinLen, bigEndianMod, outputOptions) {
+  switch (format) {
+    case "HEX":
+      return function(binarray) {
+        return packed2hex(binarray, outputBinLen, bigEndianMod, outputOptions);
+      };
+    case "B64":
+      return function(binarray) {
+        return packed2b64(binarray, outputBinLen, bigEndianMod, outputOptions);
+      };
+    case "BYTES":
+      return function(binarray) {
+        return packed2bytes(binarray, outputBinLen, bigEndianMod);
+      };
+    case "ARRAYBUFFER":
+      try {
+        new ArrayBuffer(0);
+      } catch (ignore) {
+        throw new Error(arraybuffer_error);
+      }
+      return function(binarray) {
+        return packed2arraybuffer(binarray, outputBinLen, bigEndianMod);
+      };
+    case "UINT8ARRAY":
+      try {
+        new Uint8Array(0);
+      } catch (ignore) {
+        throw new Error(uint8array_error);
+      }
+      return function(binarray) {
+        return packed2uint8array(binarray, outputBinLen, bigEndianMod);
+      };
+    default:
+      throw new Error("format must be HEX, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY");
+  }
+}
+const TWO_PWR_32 = 4294967296;
+const K_sha2 = [
+  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 H_trunc = [3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428];
+const H_full = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+const sha_variant_error = "Chosen SHA variant is not supported";
+const mac_rounds_error = "Cannot set numRounds with MAC";
+function packedLEConcat(a2, b2) {
+  let i2, arrOffset;
+  const aByteLen = a2["binLen"] >>> 3, bByteLen = b2["binLen"] >>> 3, leftShiftAmount = aByteLen << 3, rightShiftAmount = 4 - aByteLen << 3;
+  if (aByteLen % 4 !== 0) {
+    for (i2 = 0; i2 < bByteLen; i2 += 4) {
+      arrOffset = aByteLen + i2 >>> 2;
+      a2["value"][arrOffset] |= b2["value"][i2 >>> 2] << leftShiftAmount;
+      a2["value"].push(0);
+      a2["value"][arrOffset + 1] |= b2["value"][i2 >>> 2] >>> rightShiftAmount;
+    }
+    if ((a2["value"].length << 2) - 4 >= bByteLen + aByteLen) {
+      a2["value"].pop();
+    }
+    return { value: a2["value"], binLen: a2["binLen"] + b2["binLen"] };
+  } else {
+    return { value: a2["value"].concat(b2["value"]), binLen: a2["binLen"] + b2["binLen"] };
+  }
+}
+function getOutputOpts(options) {
+  const retVal = { outputUpper: false, b64Pad: "=", outputLen: -1 }, outputOptions = options || {}, lenErrstr = "Output length must be a multiple of 8";
+  retVal["outputUpper"] = outputOptions["outputUpper"] || false;
+  if (outputOptions["b64Pad"]) {
+    retVal["b64Pad"] = outputOptions["b64Pad"];
+  }
+  if (outputOptions["outputLen"]) {
+    if (outputOptions["outputLen"] % 8 !== 0) {
+      throw new Error(lenErrstr);
+    }
+    retVal["outputLen"] = outputOptions["outputLen"];
+  } else if (outputOptions["shakeLen"]) {
+    if (outputOptions["shakeLen"] % 8 !== 0) {
+      throw new Error(lenErrstr);
+    }
+    retVal["outputLen"] = outputOptions["shakeLen"];
+  }
+  if ("boolean" !== typeof retVal["outputUpper"]) {
+    throw new Error("Invalid outputUpper formatting option");
+  }
+  if ("string" !== typeof retVal["b64Pad"]) {
+    throw new Error("Invalid b64Pad formatting option");
+  }
+  return retVal;
+}
+function parseInputOption(key, value, bigEndianMod, fallback) {
+  const errStr = key + " must include a value and format";
+  if (!value) {
+    if (!fallback) {
+      throw new Error(errStr);
+    }
+    return fallback;
+  }
+  if (typeof value["value"] === "undefined" || !value["format"]) {
+    throw new Error(errStr);
+  }
+  return getStrConverter(
+    value["format"],
+    // @ts-expect-error - the value of encoding gets value checked by getStrConverter
+    value["encoding"] || "UTF8",
+    bigEndianMod
+  )(value["value"]);
+}
+class jsSHABase {
+  constructor(variant, inputFormat, options) {
+    /**
+     * @param variant The desired SHA variant.
+     * @param inputFormat The input format to be used in future `update` calls.
+     * @param options Hashmap of extra input options.
+     */
+    /* Needed inputs */
+    __publicField(this, "shaVariant");
+    __publicField(this, "inputFormat");
+    __publicField(this, "utfType");
+    __publicField(this, "numRounds");
+    __publicField(this, "keyWithIPad");
+    __publicField(this, "keyWithOPad");
+    __publicField(this, "remainder");
+    __publicField(this, "remainderLen");
+    __publicField(this, "updateCalled");
+    __publicField(this, "processedLen");
+    __publicField(this, "macKeySet");
+    const inputOptions = options || {};
+    this.inputFormat = inputFormat;
+    this.utfType = inputOptions["encoding"] || "UTF8";
+    this.numRounds = inputOptions["numRounds"] || 1;
+    if (isNaN(this.numRounds) || this.numRounds !== parseInt(this.numRounds, 10) || 1 > this.numRounds) {
+      throw new Error("numRounds must a integer >= 1");
+    }
+    this.shaVariant = variant;
+    this.remainder = [];
+    this.remainderLen = 0;
+    this.updateCalled = false;
+    this.processedLen = 0;
+    this.macKeySet = false;
+    this.keyWithIPad = [];
+    this.keyWithOPad = [];
+  }
+  /**
+   * Hashes as many blocks as possible.  Stores the rest for either a future update or getHash call.
+   *
+   * @param srcString The input to be hashed.
+   * @returns A reference to the object.
+   */
+  update(srcString) {
+    let i2, updateProcessedLen = 0;
+    const variantBlockIntInc = this.variantBlockSize >>> 5, convertRet = this.converterFunc(srcString, this.remainder, this.remainderLen), chunkBinLen = convertRet["binLen"], chunk = convertRet["value"], chunkIntLen = chunkBinLen >>> 5;
+    for (i2 = 0; i2 < chunkIntLen; i2 += variantBlockIntInc) {
+      if (updateProcessedLen + this.variantBlockSize <= chunkBinLen) {
+        this.intermediateState = this.roundFunc(chunk.slice(i2, i2 + variantBlockIntInc), this.intermediateState);
+        updateProcessedLen += this.variantBlockSize;
+      }
+    }
+    this.processedLen += updateProcessedLen;
+    this.remainder = chunk.slice(updateProcessedLen >>> 5);
+    this.remainderLen = chunkBinLen % this.variantBlockSize;
+    this.updateCalled = true;
+    return this;
+  }
+  getHash(format, options) {
+    let i2, finalizedState, outputBinLen = this.outputBinLen;
+    const outputOptions = getOutputOpts(options);
+    if (this.isVariableLen) {
+      if (outputOptions["outputLen"] === -1) {
+        throw new Error("Output length must be specified in options");
+      }
+      outputBinLen = outputOptions["outputLen"];
+    }
+    const formatFunc = getOutputConverter(format, outputBinLen, this.bigEndianMod, outputOptions);
+    if (this.macKeySet && this.getMAC) {
+      return formatFunc(this.getMAC(outputOptions));
+    }
+    finalizedState = this.finalizeFunc(
+      this.remainder.slice(),
+      this.remainderLen,
+      this.processedLen,
+      this.stateCloneFunc(this.intermediateState),
+      outputBinLen
+    );
+    for (i2 = 1; i2 < this.numRounds; i2 += 1) {
+      if (this.isVariableLen && outputBinLen % 32 !== 0) {
+        finalizedState[finalizedState.length - 1] &= 16777215 >>> 24 - outputBinLen % 32;
+      }
+      finalizedState = this.finalizeFunc(
+        finalizedState,
+        outputBinLen,
+        0,
+        this.newStateFunc(this.shaVariant),
+        outputBinLen
+      );
+    }
+    return formatFunc(finalizedState);
+  }
+  setHMACKey(key, inputFormat, options) {
+    if (!this.HMACSupported) {
+      throw new Error("Variant does not support HMAC");
+    }
+    if (this.updateCalled) {
+      throw new Error("Cannot set MAC key after calling update");
+    }
+    const keyOptions = options || {}, keyConverterFunc = getStrConverter(inputFormat, keyOptions["encoding"] || "UTF8", this.bigEndianMod);
+    this._setHMACKey(keyConverterFunc(key));
+  }
+  /**
+   * Internal function that sets the MAC key.
+   *
+   * @param key The packed MAC key to use
+   */
+  _setHMACKey(key) {
+    const blockByteSize = this.variantBlockSize >>> 3, lastArrayIndex = blockByteSize / 4 - 1;
+    let i2;
+    if (this.numRounds !== 1) {
+      throw new Error(mac_rounds_error);
+    }
+    if (this.macKeySet) {
+      throw new Error("MAC key already set");
+    }
+    if (blockByteSize < key["binLen"] / 8) {
+      key["value"] = this.finalizeFunc(
+        key["value"],
+        key["binLen"],
+        0,
+        this.newStateFunc(this.shaVariant),
+        this.outputBinLen
+      );
+    }
+    while (key["value"].length <= lastArrayIndex) {
+      key["value"].push(0);
+    }
+    for (i2 = 0; i2 <= lastArrayIndex; i2 += 1) {
+      this.keyWithIPad[i2] = key["value"][i2] ^ 909522486;
+      this.keyWithOPad[i2] = key["value"][i2] ^ 1549556828;
+    }
+    this.intermediateState = this.roundFunc(this.keyWithIPad, this.intermediateState);
+    this.processedLen = this.variantBlockSize;
+    this.macKeySet = true;
+  }
+  getHMAC(format, options) {
+    const outputOptions = getOutputOpts(options), formatFunc = getOutputConverter(format, this.outputBinLen, this.bigEndianMod, outputOptions);
+    return formatFunc(this._getHMAC());
+  }
+  /**
+   * Internal function that returns the "raw" HMAC
+   */
+  _getHMAC() {
+    let finalizedState;
+    if (!this.macKeySet) {
+      throw new Error("Cannot call getHMAC without first setting MAC key");
+    }
+    const firstHash = this.finalizeFunc(
+      this.remainder.slice(),
+      this.remainderLen,
+      this.processedLen,
+      this.stateCloneFunc(this.intermediateState),
+      this.outputBinLen
+    );
+    finalizedState = this.roundFunc(this.keyWithOPad, this.newStateFunc(this.shaVariant));
+    finalizedState = this.finalizeFunc(
+      firstHash,
+      this.outputBinLen,
+      this.variantBlockSize,
+      finalizedState,
+      this.outputBinLen
+    );
+    return finalizedState;
+  }
+}
+function rotl_32(x, n2) {
+  return x << n2 | x >>> 32 - n2;
+}
+function rotr_32(x, n2) {
+  return x >>> n2 | x << 32 - n2;
+}
+function shr_32(x, n2) {
+  return x >>> n2;
+}
+function parity_32(x, y, z) {
+  return x ^ y ^ z;
+}
+function ch_32(x, y, z) {
+  return x & y ^ ~x & z;
+}
+function maj_32(x, y, z) {
+  return x & y ^ x & z ^ y & z;
+}
+function sigma0_32(x) {
+  return rotr_32(x, 2) ^ rotr_32(x, 13) ^ rotr_32(x, 22);
+}
+function safeAdd_32_2(a2, b2) {
+  const lsw = (a2 & 65535) + (b2 & 65535), msw = (a2 >>> 16) + (b2 >>> 16) + (lsw >>> 16);
+  return (msw & 65535) << 16 | lsw & 65535;
+}
+function safeAdd_32_4(a2, b2, c2, d2) {
+  const lsw = (a2 & 65535) + (b2 & 65535) + (c2 & 65535) + (d2 & 65535), msw = (a2 >>> 16) + (b2 >>> 16) + (c2 >>> 16) + (d2 >>> 16) + (lsw >>> 16);
+  return (msw & 65535) << 16 | lsw & 65535;
+}
+function safeAdd_32_5(a2, b2, c2, d2, e2) {
+  const lsw = (a2 & 65535) + (b2 & 65535) + (c2 & 65535) + (d2 & 65535) + (e2 & 65535), msw = (a2 >>> 16) + (b2 >>> 16) + (c2 >>> 16) + (d2 >>> 16) + (e2 >>> 16) + (lsw >>> 16);
+  return (msw & 65535) << 16 | lsw & 65535;
+}
+function gamma1_32(x) {
+  return rotr_32(x, 17) ^ rotr_32(x, 19) ^ shr_32(x, 10);
+}
+function gamma0_32(x) {
+  return rotr_32(x, 7) ^ rotr_32(x, 18) ^ shr_32(x, 3);
+}
+function sigma1_32(x) {
+  return rotr_32(x, 6) ^ rotr_32(x, 11) ^ rotr_32(x, 25);
+}
+function getNewState$1(_variant) {
+  return [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+}
+function roundSHA1(block, H2) {
+  let a2, b2, c2, d2, e2, T, t2;
+  const W = [];
+  a2 = H2[0];
+  b2 = H2[1];
+  c2 = H2[2];
+  d2 = H2[3];
+  e2 = H2[4];
+  for (t2 = 0; t2 < 80; t2 += 1) {
+    if (t2 < 16) {
+      W[t2] = block[t2];
+    } else {
+      W[t2] = rotl_32(W[t2 - 3] ^ W[t2 - 8] ^ W[t2 - 14] ^ W[t2 - 16], 1);
+    }
+    if (t2 < 20) {
+      T = safeAdd_32_5(rotl_32(a2, 5), ch_32(b2, c2, d2), e2, 1518500249, W[t2]);
+    } else if (t2 < 40) {
+      T = safeAdd_32_5(rotl_32(a2, 5), parity_32(b2, c2, d2), e2, 1859775393, W[t2]);
+    } else if (t2 < 60) {
+      T = safeAdd_32_5(rotl_32(a2, 5), maj_32(b2, c2, d2), e2, 2400959708, W[t2]);
+    } else {
+      T = safeAdd_32_5(rotl_32(a2, 5), parity_32(b2, c2, d2), e2, 3395469782, W[t2]);
+    }
+    e2 = d2;
+    d2 = c2;
+    c2 = rotl_32(b2, 30);
+    b2 = a2;
+    a2 = T;
+  }
+  H2[0] = safeAdd_32_2(a2, H2[0]);
+  H2[1] = safeAdd_32_2(b2, H2[1]);
+  H2[2] = safeAdd_32_2(c2, H2[2]);
+  H2[3] = safeAdd_32_2(d2, H2[3]);
+  H2[4] = safeAdd_32_2(e2, H2[4]);
+  return H2;
+}
+function finalizeSHA1(remainder, remainderBinLen, processedBinLen, H2) {
+  let i2;
+  const offset = (remainderBinLen + 65 >>> 9 << 4) + 15, totalLen = remainderBinLen + processedBinLen;
+  while (remainder.length <= offset) {
+    remainder.push(0);
+  }
+  remainder[remainderBinLen >>> 5] |= 128 << 24 - remainderBinLen % 32;
+  remainder[offset] = totalLen & 4294967295;
+  remainder[offset - 1] = totalLen / TWO_PWR_32 | 0;
+  for (i2 = 0; i2 < remainder.length; i2 += 16) {
+    H2 = roundSHA1(remainder.slice(i2, i2 + 16), H2);
+  }
+  return H2;
+}
+let jsSHA$4 = class jsSHA extends jsSHABase {
+  constructor(variant, inputFormat, options) {
+    if ("SHA-1" !== variant) {
+      throw new Error(sha_variant_error);
+    }
+    super(variant, inputFormat, options);
+    __publicField(this, "intermediateState");
+    __publicField(this, "variantBlockSize");
+    __publicField(this, "bigEndianMod");
+    __publicField(this, "outputBinLen");
+    __publicField(this, "isVariableLen");
+    __publicField(this, "HMACSupported");
+    __publicField(this, "converterFunc");
+    __publicField(this, "roundFunc");
+    __publicField(this, "finalizeFunc");
+    __publicField(this, "stateCloneFunc");
+    __publicField(this, "newStateFunc");
+    __publicField(this, "getMAC");
+    const resolvedOptions = options || {};
+    this.HMACSupported = true;
+    this.getMAC = this._getHMAC;
+    this.bigEndianMod = -1;
+    this.converterFunc = getStrConverter(this.inputFormat, this.utfType, this.bigEndianMod);
+    this.roundFunc = roundSHA1;
+    this.stateCloneFunc = function(state) {
+      return state.slice();
+    };
+    this.newStateFunc = getNewState$1;
+    this.finalizeFunc = finalizeSHA1;
+    this.intermediateState = getNewState$1();
+    this.variantBlockSize = 512;
+    this.outputBinLen = 160;
+    this.isVariableLen = false;
+    if (resolvedOptions["hmacKey"]) {
+      this._setHMACKey(parseInputOption("hmacKey", resolvedOptions["hmacKey"], this.bigEndianMod));
+    }
+  }
+};
+function getNewState256(variant) {
+  let retVal;
+  if ("SHA-224" === variant) {
+    retVal = H_trunc.slice();
+  } else {
+    retVal = H_full.slice();
+  }
+  return retVal;
+}
+function roundSHA256(block, H2) {
+  let a2, b2, c2, d2, e2, f2, g2, h2, T1, T2, t2;
+  const W = [];
+  a2 = H2[0];
+  b2 = H2[1];
+  c2 = H2[2];
+  d2 = H2[3];
+  e2 = H2[4];
+  f2 = H2[5];
+  g2 = H2[6];
+  h2 = H2[7];
+  for (t2 = 0; t2 < 64; t2 += 1) {
+    if (t2 < 16) {
+      W[t2] = block[t2];
+    } else {
+      W[t2] = safeAdd_32_4(gamma1_32(W[t2 - 2]), W[t2 - 7], gamma0_32(W[t2 - 15]), W[t2 - 16]);
+    }
+    T1 = safeAdd_32_5(h2, sigma1_32(e2), ch_32(e2, f2, g2), K_sha2[t2], W[t2]);
+    T2 = safeAdd_32_2(sigma0_32(a2), maj_32(a2, b2, c2));
+    h2 = g2;
+    g2 = f2;
+    f2 = e2;
+    e2 = safeAdd_32_2(d2, T1);
+    d2 = c2;
+    c2 = b2;
+    b2 = a2;
+    a2 = safeAdd_32_2(T1, T2);
+  }
+  H2[0] = safeAdd_32_2(a2, H2[0]);
+  H2[1] = safeAdd_32_2(b2, H2[1]);
+  H2[2] = safeAdd_32_2(c2, H2[2]);
+  H2[3] = safeAdd_32_2(d2, H2[3]);
+  H2[4] = safeAdd_32_2(e2, H2[4]);
+  H2[5] = safeAdd_32_2(f2, H2[5]);
+  H2[6] = safeAdd_32_2(g2, H2[6]);
+  H2[7] = safeAdd_32_2(h2, H2[7]);
+  return H2;
+}
+function finalizeSHA256(remainder, remainderBinLen, processedBinLen, H2, variant) {
+  let i2, retVal;
+  const offset = (remainderBinLen + 65 >>> 9 << 4) + 15, binaryStringInc = 16, totalLen = remainderBinLen + processedBinLen;
+  while (remainder.length <= offset) {
+    remainder.push(0);
+  }
+  remainder[remainderBinLen >>> 5] |= 128 << 24 - remainderBinLen % 32;
+  remainder[offset] = totalLen & 4294967295;
+  remainder[offset - 1] = totalLen / TWO_PWR_32 | 0;
+  for (i2 = 0; i2 < remainder.length; i2 += binaryStringInc) {
+    H2 = roundSHA256(remainder.slice(i2, i2 + binaryStringInc), H2);
+  }
+  if ("SHA-224" === variant) {
+    retVal = [H2[0], H2[1], H2[2], H2[3], H2[4], H2[5], H2[6]];
+  } else {
+    retVal = H2;
+  }
+  return retVal;
+}
+let jsSHA$3 = class jsSHA2 extends jsSHABase {
+  constructor(variant, inputFormat, options) {
+    if (!("SHA-224" === variant || "SHA-256" === variant)) {
+      throw new Error(sha_variant_error);
+    }
+    super(variant, inputFormat, options);
+    __publicField(this, "intermediateState");
+    __publicField(this, "variantBlockSize");
+    __publicField(this, "bigEndianMod");
+    __publicField(this, "outputBinLen");
+    __publicField(this, "isVariableLen");
+    __publicField(this, "HMACSupported");
+    __publicField(this, "converterFunc");
+    __publicField(this, "roundFunc");
+    __publicField(this, "finalizeFunc");
+    __publicField(this, "stateCloneFunc");
+    __publicField(this, "newStateFunc");
+    __publicField(this, "getMAC");
+    const resolvedOptions = options || {};
+    this.getMAC = this._getHMAC;
+    this.HMACSupported = true;
+    this.bigEndianMod = -1;
+    this.converterFunc = getStrConverter(this.inputFormat, this.utfType, this.bigEndianMod);
+    this.roundFunc = roundSHA256;
+    this.stateCloneFunc = function(state) {
+      return state.slice();
+    };
+    this.newStateFunc = getNewState256;
+    this.finalizeFunc = function(remainder, remainderBinLen, processedBinLen, H2) {
+      return finalizeSHA256(remainder, remainderBinLen, processedBinLen, H2, variant);
+    };
+    this.intermediateState = getNewState256(variant);
+    this.variantBlockSize = 512;
+    this.outputBinLen = "SHA-224" === variant ? 224 : 256;
+    this.isVariableLen = false;
+    if (resolvedOptions["hmacKey"]) {
+      this._setHMACKey(parseInputOption("hmacKey", resolvedOptions["hmacKey"], this.bigEndianMod));
+    }
+  }
+};
+class Int_64 {
+  constructor(msint_32, lsint_32) {
+    /**
+     * @param msint_32 The most significant 32-bits of a 64-bit number.
+     * @param lsint_32 The least significant 32-bits of a 64-bit number.
+     */
+    __publicField(this, "highOrder");
+    __publicField(this, "lowOrder");
+    this.highOrder = msint_32;
+    this.lowOrder = lsint_32;
+  }
+}
+function rotl_64(x, n2) {
+  let tmp;
+  if (n2 > 32) {
+    tmp = 64 - n2;
+    return new Int_64(x.lowOrder << n2 | x.highOrder >>> tmp, x.highOrder << n2 | x.lowOrder >>> tmp);
+  } else if (0 !== n2) {
+    tmp = 32 - n2;
+    return new Int_64(x.highOrder << n2 | x.lowOrder >>> tmp, x.lowOrder << n2 | x.highOrder >>> tmp);
+  } else {
+    return x;
+  }
+}
+function rotr_64(x, n2) {
+  let tmp;
+  if (n2 < 32) {
+    tmp = 32 - n2;
+    return new Int_64(x.highOrder >>> n2 | x.lowOrder << tmp, x.lowOrder >>> n2 | x.highOrder << tmp);
+  } else {
+    tmp = 64 - n2;
+    return new Int_64(x.lowOrder >>> n2 | x.highOrder << tmp, x.highOrder >>> n2 | x.lowOrder << tmp);
+  }
+}
+function shr_64(x, n2) {
+  return new Int_64(x.highOrder >>> n2, x.lowOrder >>> n2 | x.highOrder << 32 - n2);
+}
+function ch_64(x, y, z) {
+  return new Int_64(
+    x.highOrder & y.highOrder ^ ~x.highOrder & z.highOrder,
+    x.lowOrder & y.lowOrder ^ ~x.lowOrder & z.lowOrder
+  );
+}
+function maj_64(x, y, z) {
+  return new Int_64(
+    x.highOrder & y.highOrder ^ x.highOrder & z.highOrder ^ y.highOrder & z.highOrder,
+    x.lowOrder & y.lowOrder ^ x.lowOrder & z.lowOrder ^ y.lowOrder & z.lowOrder
+  );
+}
+function sigma0_64(x) {
+  const rotr28 = rotr_64(x, 28), rotr34 = rotr_64(x, 34), rotr39 = rotr_64(x, 39);
+  return new Int_64(
+    rotr28.highOrder ^ rotr34.highOrder ^ rotr39.highOrder,
+    rotr28.lowOrder ^ rotr34.lowOrder ^ rotr39.lowOrder
+  );
+}
+function safeAdd_64_2(x, y) {
+  let lsw, msw;
+  lsw = (x.lowOrder & 65535) + (y.lowOrder & 65535);
+  msw = (x.lowOrder >>> 16) + (y.lowOrder >>> 16) + (lsw >>> 16);
+  const lowOrder = (msw & 65535) << 16 | lsw & 65535;
+  lsw = (x.highOrder & 65535) + (y.highOrder & 65535) + (msw >>> 16);
+  msw = (x.highOrder >>> 16) + (y.highOrder >>> 16) + (lsw >>> 16);
+  const highOrder = (msw & 65535) << 16 | lsw & 65535;
+  return new Int_64(highOrder, lowOrder);
+}
+function safeAdd_64_4(a2, b2, c2, d2) {
+  let lsw, msw;
+  lsw = (a2.lowOrder & 65535) + (b2.lowOrder & 65535) + (c2.lowOrder & 65535) + (d2.lowOrder & 65535);
+  msw = (a2.lowOrder >>> 16) + (b2.lowOrder >>> 16) + (c2.lowOrder >>> 16) + (d2.lowOrder >>> 16) + (lsw >>> 16);
+  const lowOrder = (msw & 65535) << 16 | lsw & 65535;
+  lsw = (a2.highOrder & 65535) + (b2.highOrder & 65535) + (c2.highOrder & 65535) + (d2.highOrder & 65535) + (msw >>> 16);
+  msw = (a2.highOrder >>> 16) + (b2.highOrder >>> 16) + (c2.highOrder >>> 16) + (d2.highOrder >>> 16) + (lsw >>> 16);
+  const highOrder = (msw & 65535) << 16 | lsw & 65535;
+  return new Int_64(highOrder, lowOrder);
+}
+function safeAdd_64_5(a2, b2, c2, d2, e2) {
+  let lsw, msw;
+  lsw = (a2.lowOrder & 65535) + (b2.lowOrder & 65535) + (c2.lowOrder & 65535) + (d2.lowOrder & 65535) + (e2.lowOrder & 65535);
+  msw = (a2.lowOrder >>> 16) + (b2.lowOrder >>> 16) + (c2.lowOrder >>> 16) + (d2.lowOrder >>> 16) + (e2.lowOrder >>> 16) + (lsw >>> 16);
+  const lowOrder = (msw & 65535) << 16 | lsw & 65535;
+  lsw = (a2.highOrder & 65535) + (b2.highOrder & 65535) + (c2.highOrder & 65535) + (d2.highOrder & 65535) + (e2.highOrder & 65535) + (msw >>> 16);
+  msw = (a2.highOrder >>> 16) + (b2.highOrder >>> 16) + (c2.highOrder >>> 16) + (d2.highOrder >>> 16) + (e2.highOrder >>> 16) + (lsw >>> 16);
+  const highOrder = (msw & 65535) << 16 | lsw & 65535;
+  return new Int_64(highOrder, lowOrder);
+}
+function xor_64_2(a2, b2) {
+  return new Int_64(a2.highOrder ^ b2.highOrder, a2.lowOrder ^ b2.lowOrder);
+}
+function xor_64_5(a2, b2, c2, d2, e2) {
+  return new Int_64(
+    a2.highOrder ^ b2.highOrder ^ c2.highOrder ^ d2.highOrder ^ e2.highOrder,
+    a2.lowOrder ^ b2.lowOrder ^ c2.lowOrder ^ d2.lowOrder ^ e2.lowOrder
+  );
+}
+function gamma1_64(x) {
+  const rotr19 = rotr_64(x, 19), rotr61 = rotr_64(x, 61), shr6 = shr_64(x, 6);
+  return new Int_64(
+    rotr19.highOrder ^ rotr61.highOrder ^ shr6.highOrder,
+    rotr19.lowOrder ^ rotr61.lowOrder ^ shr6.lowOrder
+  );
+}
+function gamma0_64(x) {
+  const rotr1 = rotr_64(x, 1), rotr8 = rotr_64(x, 8), shr7 = shr_64(x, 7);
+  return new Int_64(
+    rotr1.highOrder ^ rotr8.highOrder ^ shr7.highOrder,
+    rotr1.lowOrder ^ rotr8.lowOrder ^ shr7.lowOrder
+  );
+}
+function sigma1_64(x) {
+  const rotr14 = rotr_64(x, 14), rotr18 = rotr_64(x, 18), rotr41 = rotr_64(x, 41);
+  return new Int_64(
+    rotr14.highOrder ^ rotr18.highOrder ^ rotr41.highOrder,
+    rotr14.lowOrder ^ rotr18.lowOrder ^ rotr41.lowOrder
+  );
+}
+const K_sha512 = [
+  new Int_64(K_sha2[0], 3609767458),
+  new Int_64(K_sha2[1], 602891725),
+  new Int_64(K_sha2[2], 3964484399),
+  new Int_64(K_sha2[3], 2173295548),
+  new Int_64(K_sha2[4], 4081628472),
+  new Int_64(K_sha2[5], 3053834265),
+  new Int_64(K_sha2[6], 2937671579),
+  new Int_64(K_sha2[7], 3664609560),
+  new Int_64(K_sha2[8], 2734883394),
+  new Int_64(K_sha2[9], 1164996542),
+  new Int_64(K_sha2[10], 1323610764),
+  new Int_64(K_sha2[11], 3590304994),
+  new Int_64(K_sha2[12], 4068182383),
+  new Int_64(K_sha2[13], 991336113),
+  new Int_64(K_sha2[14], 633803317),
+  new Int_64(K_sha2[15], 3479774868),
+  new Int_64(K_sha2[16], 2666613458),
+  new Int_64(K_sha2[17], 944711139),
+  new Int_64(K_sha2[18], 2341262773),
+  new Int_64(K_sha2[19], 2007800933),
+  new Int_64(K_sha2[20], 1495990901),
+  new Int_64(K_sha2[21], 1856431235),
+  new Int_64(K_sha2[22], 3175218132),
+  new Int_64(K_sha2[23], 2198950837),
+  new Int_64(K_sha2[24], 3999719339),
+  new Int_64(K_sha2[25], 766784016),
+  new Int_64(K_sha2[26], 2566594879),
+  new Int_64(K_sha2[27], 3203337956),
+  new Int_64(K_sha2[28], 1034457026),
+  new Int_64(K_sha2[29], 2466948901),
+  new Int_64(K_sha2[30], 3758326383),
+  new Int_64(K_sha2[31], 168717936),
+  new Int_64(K_sha2[32], 1188179964),
+  new Int_64(K_sha2[33], 1546045734),
+  new Int_64(K_sha2[34], 1522805485),
+  new Int_64(K_sha2[35], 2643833823),
+  new Int_64(K_sha2[36], 2343527390),
+  new Int_64(K_sha2[37], 1014477480),
+  new Int_64(K_sha2[38], 1206759142),
+  new Int_64(K_sha2[39], 344077627),
+  new Int_64(K_sha2[40], 1290863460),
+  new Int_64(K_sha2[41], 3158454273),
+  new Int_64(K_sha2[42], 3505952657),
+  new Int_64(K_sha2[43], 106217008),
+  new Int_64(K_sha2[44], 3606008344),
+  new Int_64(K_sha2[45], 1432725776),
+  new Int_64(K_sha2[46], 1467031594),
+  new Int_64(K_sha2[47], 851169720),
+  new Int_64(K_sha2[48], 3100823752),
+  new Int_64(K_sha2[49], 1363258195),
+  new Int_64(K_sha2[50], 3750685593),
+  new Int_64(K_sha2[51], 3785050280),
+  new Int_64(K_sha2[52], 3318307427),
+  new Int_64(K_sha2[53], 3812723403),
+  new Int_64(K_sha2[54], 2003034995),
+  new Int_64(K_sha2[55], 3602036899),
+  new Int_64(K_sha2[56], 1575990012),
+  new Int_64(K_sha2[57], 1125592928),
+  new Int_64(K_sha2[58], 2716904306),
+  new Int_64(K_sha2[59], 442776044),
+  new Int_64(K_sha2[60], 593698344),
+  new Int_64(K_sha2[61], 3733110249),
+  new Int_64(K_sha2[62], 2999351573),
+  new Int_64(K_sha2[63], 3815920427),
+  new Int_64(3391569614, 3928383900),
+  new Int_64(3515267271, 566280711),
+  new Int_64(3940187606, 3454069534),
+  new Int_64(4118630271, 4000239992),
+  new Int_64(116418474, 1914138554),
+  new Int_64(174292421, 2731055270),
+  new Int_64(289380356, 3203993006),
+  new Int_64(460393269, 320620315),
+  new Int_64(685471733, 587496836),
+  new Int_64(852142971, 1086792851),
+  new Int_64(1017036298, 365543100),
+  new Int_64(1126000580, 2618297676),
+  new Int_64(1288033470, 3409855158),
+  new Int_64(1501505948, 4234509866),
+  new Int_64(1607167915, 987167468),
+  new Int_64(1816402316, 1246189591)
+];
+function getNewState512(variant) {
+  if ("SHA-384" === variant) {
+    return [
+      new Int_64(3418070365, H_trunc[0]),
+      new Int_64(1654270250, H_trunc[1]),
+      new Int_64(2438529370, H_trunc[2]),
+      new Int_64(355462360, H_trunc[3]),
+      new Int_64(1731405415, H_trunc[4]),
+      new Int_64(41048885895, H_trunc[5]),
+      new Int_64(3675008525, H_trunc[6]),
+      new Int_64(1203062813, H_trunc[7])
+    ];
+  } else {
+    return [
+      new Int_64(H_full[0], 4089235720),
+      new Int_64(H_full[1], 2227873595),
+      new Int_64(H_full[2], 4271175723),
+      new Int_64(H_full[3], 1595750129),
+      new Int_64(H_full[4], 2917565137),
+      new Int_64(H_full[5], 725511199),
+      new Int_64(H_full[6], 4215389547),
+      new Int_64(H_full[7], 327033209)
+    ];
+  }
+}
+function roundSHA512(block, H2) {
+  let a2, b2, c2, d2, e2, f2, g2, h2, T1, T2, t2, offset;
+  const W = [];
+  a2 = H2[0];
+  b2 = H2[1];
+  c2 = H2[2];
+  d2 = H2[3];
+  e2 = H2[4];
+  f2 = H2[5];
+  g2 = H2[6];
+  h2 = H2[7];
+  for (t2 = 0; t2 < 80; t2 += 1) {
+    if (t2 < 16) {
+      offset = t2 * 2;
+      W[t2] = new Int_64(block[offset], block[offset + 1]);
+    } else {
+      W[t2] = safeAdd_64_4(gamma1_64(W[t2 - 2]), W[t2 - 7], gamma0_64(W[t2 - 15]), W[t2 - 16]);
+    }
+    T1 = safeAdd_64_5(h2, sigma1_64(e2), ch_64(e2, f2, g2), K_sha512[t2], W[t2]);
+    T2 = safeAdd_64_2(sigma0_64(a2), maj_64(a2, b2, c2));
+    h2 = g2;
+    g2 = f2;
+    f2 = e2;
+    e2 = safeAdd_64_2(d2, T1);
+    d2 = c2;
+    c2 = b2;
+    b2 = a2;
+    a2 = safeAdd_64_2(T1, T2);
+  }
+  H2[0] = safeAdd_64_2(a2, H2[0]);
+  H2[1] = safeAdd_64_2(b2, H2[1]);
+  H2[2] = safeAdd_64_2(c2, H2[2]);
+  H2[3] = safeAdd_64_2(d2, H2[3]);
+  H2[4] = safeAdd_64_2(e2, H2[4]);
+  H2[5] = safeAdd_64_2(f2, H2[5]);
+  H2[6] = safeAdd_64_2(g2, H2[6]);
+  H2[7] = safeAdd_64_2(h2, H2[7]);
+  return H2;
+}
+function finalizeSHA512(remainder, remainderBinLen, processedBinLen, H2, variant) {
+  let i2, retVal;
+  const offset = (remainderBinLen + 129 >>> 10 << 5) + 31, binaryStringInc = 32, totalLen = remainderBinLen + processedBinLen;
+  while (remainder.length <= offset) {
+    remainder.push(0);
+  }
+  remainder[remainderBinLen >>> 5] |= 128 << 24 - remainderBinLen % 32;
+  remainder[offset] = totalLen & 4294967295;
+  remainder[offset - 1] = totalLen / TWO_PWR_32 | 0;
+  for (i2 = 0; i2 < remainder.length; i2 += binaryStringInc) {
+    H2 = roundSHA512(remainder.slice(i2, i2 + binaryStringInc), H2);
+  }
+  if ("SHA-384" === variant) {
+    H2 = H2;
+    retVal = [
+      H2[0].highOrder,
+      H2[0].lowOrder,
+      H2[1].highOrder,
+      H2[1].lowOrder,
+      H2[2].highOrder,
+      H2[2].lowOrder,
+      H2[3].highOrder,
+      H2[3].lowOrder,
+      H2[4].highOrder,
+      H2[4].lowOrder,
+      H2[5].highOrder,
+      H2[5].lowOrder
+    ];
+  } else {
+    retVal = [
+      H2[0].highOrder,
+      H2[0].lowOrder,
+      H2[1].highOrder,
+      H2[1].lowOrder,
+      H2[2].highOrder,
+      H2[2].lowOrder,
+      H2[3].highOrder,
+      H2[3].lowOrder,
+      H2[4].highOrder,
+      H2[4].lowOrder,
+      H2[5].highOrder,
+      H2[5].lowOrder,
+      H2[6].highOrder,
+      H2[6].lowOrder,
+      H2[7].highOrder,
+      H2[7].lowOrder
+    ];
+  }
+  return retVal;
+}
+let jsSHA$2 = class jsSHA3 extends jsSHABase {
+  constructor(variant, inputFormat, options) {
+    if (!("SHA-384" === variant || "SHA-512" === variant)) {
+      throw new Error(sha_variant_error);
+    }
+    super(variant, inputFormat, options);
+    __publicField(this, "intermediateState");
+    __publicField(this, "variantBlockSize");
+    __publicField(this, "bigEndianMod");
+    __publicField(this, "outputBinLen");
+    __publicField(this, "isVariableLen");
+    __publicField(this, "HMACSupported");
+    __publicField(this, "converterFunc");
+    __publicField(this, "roundFunc");
+    __publicField(this, "finalizeFunc");
+    __publicField(this, "stateCloneFunc");
+    __publicField(this, "newStateFunc");
+    __publicField(this, "getMAC");
+    const resolvedOptions = options || {};
+    this.getMAC = this._getHMAC;
+    this.HMACSupported = true;
+    this.bigEndianMod = -1;
+    this.converterFunc = getStrConverter(this.inputFormat, this.utfType, this.bigEndianMod);
+    this.roundFunc = roundSHA512;
+    this.stateCloneFunc = function(state) {
+      return state.slice();
+    };
+    this.newStateFunc = getNewState512;
+    this.finalizeFunc = function(remainder, remainderBinLen, processedBinLen, H2) {
+      return finalizeSHA512(remainder, remainderBinLen, processedBinLen, H2, variant);
+    };
+    this.intermediateState = getNewState512(variant);
+    this.variantBlockSize = 1024;
+    this.outputBinLen = "SHA-384" === variant ? 384 : 512;
+    this.isVariableLen = false;
+    if (resolvedOptions["hmacKey"]) {
+      this._setHMACKey(parseInputOption("hmacKey", resolvedOptions["hmacKey"], this.bigEndianMod));
+    }
+  }
+};
+const rc_sha3 = [
+  new Int_64(0, 1),
+  new Int_64(0, 32898),
+  new Int_64(2147483648, 32906),
+  new Int_64(2147483648, 2147516416),
+  new Int_64(0, 32907),
+  new Int_64(0, 2147483649),
+  new Int_64(2147483648, 2147516545),
+  new Int_64(2147483648, 32777),
+  new Int_64(0, 138),
+  new Int_64(0, 136),
+  new Int_64(0, 2147516425),
+  new Int_64(0, 2147483658),
+  new Int_64(0, 2147516555),
+  new Int_64(2147483648, 139),
+  new Int_64(2147483648, 32905),
+  new Int_64(2147483648, 32771),
+  new Int_64(2147483648, 32770),
+  new Int_64(2147483648, 128),
+  new Int_64(0, 32778),
+  new Int_64(2147483648, 2147483658),
+  new Int_64(2147483648, 2147516545),
+  new Int_64(2147483648, 32896),
+  new Int_64(0, 2147483649),
+  new Int_64(2147483648, 2147516424)
+];
+const r_sha3 = [
+  [0, 36, 3, 41, 18],
+  [1, 44, 10, 45, 2],
+  [62, 6, 43, 15, 61],
+  [28, 55, 25, 21, 56],
+  [27, 20, 39, 8, 14]
+];
+function getNewState(_variant) {
+  let i2;
+  const retVal = [];
+  for (i2 = 0; i2 < 5; i2 += 1) {
+    retVal[i2] = [new Int_64(0, 0), new Int_64(0, 0), new Int_64(0, 0), new Int_64(0, 0), new Int_64(0, 0)];
+  }
+  return retVal;
+}
+function cloneSHA3State(state) {
+  let i2;
+  const clone = [];
+  for (i2 = 0; i2 < 5; i2 += 1) {
+    clone[i2] = state[i2].slice();
+  }
+  return clone;
+}
+function roundSHA3(block, state) {
+  let round, x, y, B;
+  const C2 = [], D = [];
+  if (null != block) {
+    for (x = 0; x < block.length; x += 2) {
+      state[(x >>> 1) % 5][(x >>> 1) / 5 | 0] = xor_64_2(
+        state[(x >>> 1) % 5][(x >>> 1) / 5 | 0],
+        new Int_64(block[x + 1], block[x])
+      );
+    }
+  }
+  for (round = 0; round < 24; round += 1) {
+    B = getNewState();
+    for (x = 0; x < 5; x += 1) {
+      C2[x] = xor_64_5(state[x][0], state[x][1], state[x][2], state[x][3], state[x][4]);
+    }
+    for (x = 0; x < 5; x += 1) {
+      D[x] = xor_64_2(C2[(x + 4) % 5], rotl_64(C2[(x + 1) % 5], 1));
+    }
+    for (x = 0; x < 5; x += 1) {
+      for (y = 0; y < 5; y += 1) {
+        state[x][y] = xor_64_2(state[x][y], D[x]);
+      }
+    }
+    for (x = 0; x < 5; x += 1) {
+      for (y = 0; y < 5; y += 1) {
+        B[y][(2 * x + 3 * y) % 5] = rotl_64(state[x][y], r_sha3[x][y]);
+      }
+    }
+    for (x = 0; x < 5; x += 1) {
+      for (y = 0; y < 5; y += 1) {
+        state[x][y] = xor_64_2(
+          B[x][y],
+          new Int_64(
+            ~B[(x + 1) % 5][y].highOrder & B[(x + 2) % 5][y].highOrder,
+            ~B[(x + 1) % 5][y].lowOrder & B[(x + 2) % 5][y].lowOrder
+          )
+        );
+      }
+    }
+    state[0][0] = xor_64_2(state[0][0], rc_sha3[round]);
+  }
+  return state;
+}
+function finalizeSHA3(remainder, remainderBinLen, _processedBinLen, state, blockSize, delimiter, outputLen) {
+  let i2, state_offset = 0, temp;
+  const retVal = [], binaryStringInc = blockSize >>> 5, remainderIntLen = remainderBinLen >>> 5;
+  for (i2 = 0; i2 < remainderIntLen && remainderBinLen >= blockSize; i2 += binaryStringInc) {
+    state = roundSHA3(remainder.slice(i2, i2 + binaryStringInc), state);
+    remainderBinLen -= blockSize;
+  }
+  remainder = remainder.slice(i2);
+  remainderBinLen = remainderBinLen % blockSize;
+  while (remainder.length < binaryStringInc) {
+    remainder.push(0);
+  }
+  i2 = remainderBinLen >>> 3;
+  remainder[i2 >> 2] ^= delimiter << 8 * (i2 % 4);
+  remainder[binaryStringInc - 1] ^= 2147483648;
+  state = roundSHA3(remainder, state);
+  while (retVal.length * 32 < outputLen) {
+    temp = state[state_offset % 5][state_offset / 5 | 0];
+    retVal.push(temp.lowOrder);
+    if (retVal.length * 32 >= outputLen) {
+      break;
+    }
+    retVal.push(temp.highOrder);
+    state_offset += 1;
+    if (0 === state_offset * 64 % blockSize) {
+      roundSHA3(null, state);
+      state_offset = 0;
+    }
+  }
+  return retVal;
+}
+function left_encode(x) {
+  let byteOffset, byte, numEncodedBytes = 0;
+  const retVal = [0, 0], x_64 = [x & 4294967295, x / TWO_PWR_32 & 2097151];
+  for (byteOffset = 6; byteOffset >= 0; byteOffset--) {
+    byte = x_64[byteOffset >> 2] >>> 8 * byteOffset & 255;
+    if (byte !== 0 || numEncodedBytes !== 0) {
+      retVal[numEncodedBytes + 1 >> 2] |= byte << (numEncodedBytes + 1) * 8;
+      numEncodedBytes += 1;
+    }
+  }
+  numEncodedBytes = numEncodedBytes !== 0 ? numEncodedBytes : 1;
+  retVal[0] |= numEncodedBytes;
+  return { value: numEncodedBytes + 1 > 4 ? retVal : [retVal[0]], binLen: 8 + numEncodedBytes * 8 };
+}
+function right_encode(x) {
+  let byteOffset, byte, numEncodedBytes = 0;
+  const retVal = [0, 0], x_64 = [x & 4294967295, x / TWO_PWR_32 & 2097151];
+  for (byteOffset = 6; byteOffset >= 0; byteOffset--) {
+    byte = x_64[byteOffset >> 2] >>> 8 * byteOffset & 255;
+    if (byte !== 0 || numEncodedBytes !== 0) {
+      retVal[numEncodedBytes >> 2] |= byte << numEncodedBytes * 8;
+      numEncodedBytes += 1;
+    }
+  }
+  numEncodedBytes = numEncodedBytes !== 0 ? numEncodedBytes : 1;
+  retVal[numEncodedBytes >> 2] |= numEncodedBytes << numEncodedBytes * 8;
+  return { value: numEncodedBytes + 1 > 4 ? retVal : [retVal[0]], binLen: 8 + numEncodedBytes * 8 };
+}
+function encode_string(input) {
+  return packedLEConcat(left_encode(input["binLen"]), input);
+}
+function byte_pad(packed, outputByteLen) {
+  let encodedLen = left_encode(outputByteLen), i2;
+  encodedLen = packedLEConcat(encodedLen, packed);
+  const outputIntLen = outputByteLen >>> 2, intsToAppend = (outputIntLen - encodedLen["value"].length % outputIntLen) % outputIntLen;
+  for (i2 = 0; i2 < intsToAppend; i2++) {
+    encodedLen["value"].push(0);
+  }
+  return encodedLen["value"];
+}
+function resolveCSHAKEOptions(options) {
+  const resolvedOptions = options || {};
+  return {
+    funcName: parseInputOption("funcName", resolvedOptions["funcName"], 1, { value: [], binLen: 0 }),
+    customization: parseInputOption("Customization", resolvedOptions["customization"], 1, { value: [], binLen: 0 })
+  };
+}
+function resolveKMACOptions(options) {
+  const resolvedOptions = options || {};
+  return {
+    kmacKey: parseInputOption("kmacKey", resolvedOptions["kmacKey"], 1),
+    /* This is little-endian packed "KMAC" */
+    funcName: { value: [1128353099], binLen: 32 },
+    customization: parseInputOption("Customization", resolvedOptions["customization"], 1, { value: [], binLen: 0 })
+  };
+}
+let jsSHA$1 = class jsSHA4 extends jsSHABase {
+  constructor(variant, inputFormat, options) {
+    let delimiter = 6, variantBlockSize = 0;
+    super(variant, inputFormat, options);
+    __publicField(this, "intermediateState");
+    __publicField(this, "variantBlockSize");
+    __publicField(this, "bigEndianMod");
+    __publicField(this, "outputBinLen");
+    __publicField(this, "isVariableLen");
+    __publicField(this, "HMACSupported");
+    __publicField(this, "converterFunc");
+    __publicField(this, "roundFunc");
+    __publicField(this, "finalizeFunc");
+    __publicField(this, "stateCloneFunc");
+    __publicField(this, "newStateFunc");
+    __publicField(this, "getMAC");
+    const resolvedOptions = options || {};
+    if (this.numRounds !== 1) {
+      if (resolvedOptions["kmacKey"] || resolvedOptions["hmacKey"]) {
+        throw new Error(mac_rounds_error);
+      } else if (this.shaVariant === "CSHAKE128" || this.shaVariant === "CSHAKE256") {
+        throw new Error("Cannot set numRounds for CSHAKE variants");
+      }
+    }
+    this.bigEndianMod = 1;
+    this.converterFunc = getStrConverter(this.inputFormat, this.utfType, this.bigEndianMod);
+    this.roundFunc = roundSHA3;
+    this.stateCloneFunc = cloneSHA3State;
+    this.newStateFunc = getNewState;
+    this.intermediateState = getNewState();
+    this.isVariableLen = false;
+    switch (variant) {
+      case "SHA3-224":
+        this.variantBlockSize = variantBlockSize = 1152;
+        this.outputBinLen = 224;
+        this.HMACSupported = true;
+        this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-256":
+        this.variantBlockSize = variantBlockSize = 1088;
+        this.outputBinLen = 256;
+        this.HMACSupported = true;
+        this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-384":
+        this.variantBlockSize = variantBlockSize = 832;
+        this.outputBinLen = 384;
+        this.HMACSupported = true;
+        this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-512":
+        this.variantBlockSize = variantBlockSize = 576;
+        this.outputBinLen = 512;
+        this.HMACSupported = true;
+        this.getMAC = this._getHMAC;
+        break;
+      case "SHAKE128":
+        delimiter = 31;
+        this.variantBlockSize = variantBlockSize = 1344;
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = null;
+        break;
+      case "SHAKE256":
+        delimiter = 31;
+        this.variantBlockSize = variantBlockSize = 1088;
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = null;
+        break;
+      case "KMAC128":
+        delimiter = 4;
+        this.variantBlockSize = variantBlockSize = 1344;
+        this._initializeKMAC(options);
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = this._getKMAC;
+        break;
+      case "KMAC256":
+        delimiter = 4;
+        this.variantBlockSize = variantBlockSize = 1088;
+        this._initializeKMAC(options);
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = this._getKMAC;
+        break;
+      case "CSHAKE128":
+        this.variantBlockSize = variantBlockSize = 1344;
+        delimiter = this._initializeCSHAKE(options);
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = null;
+        break;
+      case "CSHAKE256":
+        this.variantBlockSize = variantBlockSize = 1088;
+        delimiter = this._initializeCSHAKE(options);
+        this.outputBinLen = -1;
+        this.isVariableLen = true;
+        this.HMACSupported = false;
+        this.getMAC = null;
+        break;
+      default:
+        throw new Error(sha_variant_error);
+    }
+    this.finalizeFunc = function(remainder, remainderBinLen, processedBinLen, state, outputBinLen) {
+      return finalizeSHA3(
+        remainder,
+        remainderBinLen,
+        processedBinLen,
+        state,
+        variantBlockSize,
+        delimiter,
+        outputBinLen
+      );
+    };
+    if (resolvedOptions["hmacKey"]) {
+      this._setHMACKey(parseInputOption("hmacKey", resolvedOptions["hmacKey"], this.bigEndianMod));
+    }
+  }
+  /**
+   * Initialize CSHAKE variants.
+   *
+   * @param options Options containing CSHAKE params.
+   * @param funcNameOverride Overrides any "funcName" present in `options` (used with KMAC)
+   * @returns The delimiter to be used
+   */
+  _initializeCSHAKE(options, funcNameOverride) {
+    const resolvedOptions = resolveCSHAKEOptions(options || {});
+    if (funcNameOverride) {
+      resolvedOptions["funcName"] = funcNameOverride;
+    }
+    const packedParams = packedLEConcat(
+      encode_string(resolvedOptions["funcName"]),
+      encode_string(resolvedOptions["customization"])
+    );
+    if (resolvedOptions["customization"]["binLen"] !== 0 || resolvedOptions["funcName"]["binLen"] !== 0) {
+      const byte_pad_out = byte_pad(packedParams, this.variantBlockSize >>> 3);
+      for (let i2 = 0; i2 < byte_pad_out.length; i2 += this.variantBlockSize >>> 5) {
+        this.intermediateState = this.roundFunc(
+          byte_pad_out.slice(i2, i2 + (this.variantBlockSize >>> 5)),
+          this.intermediateState
+        );
+        this.processedLen += this.variantBlockSize;
+      }
+      return 4;
+    } else {
+      return 31;
+    }
+  }
+  /**
+   * Initialize KMAC variants.
+   *
+   * @param options Options containing KMAC params.
+   */
+  _initializeKMAC(options) {
+    const resolvedOptions = resolveKMACOptions(options || {});
+    this._initializeCSHAKE(options, resolvedOptions["funcName"]);
+    const byte_pad_out = byte_pad(encode_string(resolvedOptions["kmacKey"]), this.variantBlockSize >>> 3);
+    for (let i2 = 0; i2 < byte_pad_out.length; i2 += this.variantBlockSize >>> 5) {
+      this.intermediateState = this.roundFunc(
+        byte_pad_out.slice(i2, i2 + (this.variantBlockSize >>> 5)),
+        this.intermediateState
+      );
+      this.processedLen += this.variantBlockSize;
+    }
+    this.macKeySet = true;
+  }
+  /**
+   * Returns the the KMAC in the specified format.
+   *
+   * @param options Hashmap of extra outputs options. `outputLen` must be specified.
+   * @returns The KMAC in the format specified.
+   */
+  _getKMAC(options) {
+    const concatedRemainder = packedLEConcat(
+      { value: this.remainder.slice(), binLen: this.remainderLen },
+      right_encode(options["outputLen"])
+    );
+    return this.finalizeFunc(
+      concatedRemainder["value"],
+      concatedRemainder["binLen"],
+      this.processedLen,
+      this.stateCloneFunc(this.intermediateState),
+      options["outputLen"]
+    );
+  }
+};
+class jsSHA5 {
+  constructor(variant, inputFormat, options) {
+    __publicField(this, "shaObj");
+    if ("SHA-1" === variant) {
+      this.shaObj = new jsSHA$4(variant, inputFormat, options);
+    } else if ("SHA-224" === variant || "SHA-256" === variant) {
+      this.shaObj = new jsSHA$3(variant, inputFormat, options);
+    } else if ("SHA-384" === variant || "SHA-512" === variant) {
+      this.shaObj = new jsSHA$2(variant, inputFormat, options);
+    } else if ("SHA3-224" === variant || "SHA3-256" === variant || "SHA3-384" === variant || "SHA3-512" === variant || "SHAKE128" === variant || "SHAKE256" === variant || "CSHAKE128" === variant || "CSHAKE256" === variant || "KMAC128" === variant || "KMAC256" === variant) {
+      this.shaObj = new jsSHA$1(variant, inputFormat, options);
+    } else {
+      throw new Error(sha_variant_error);
+    }
+  }
+  /**
+   * Takes `input` and hashes as many blocks as possible. Stores the rest for either a future `update` or `getHash` call.
+   *
+   * @param input The input to be hashed.
+   * @returns A reference to the object.
+   */
+  update(input) {
+    this.shaObj.update(input);
+    return this;
+  }
+  getHash(format, options) {
+    return this.shaObj.getHash(format, options);
+  }
+  setHMACKey(key, inputFormat, options) {
+    this.shaObj.setHMACKey(key, inputFormat, options);
+  }
+  getHMAC(format, options) {
+    return this.shaObj.getHMAC(format, options);
+  }
+}
+class TOTP {
+  static generate(key, options) {
+    const _options = {
+      digits: 6,
+      algorithm: "SHA-1",
+      period: 30,
+      timestamp: Date.now(),
+      ...options
+    };
+    const epoch = Math.floor(_options.timestamp / 1e3);
+    const time = this.leftpad(this.dec2hex(Math.floor(epoch / _options.period)), 16, "0");
+    const shaObj = new jsSHA5(_options.algorithm, "HEX");
+    shaObj.setHMACKey(this.base32tohex(key), "HEX");
+    shaObj.update(time);
+    const hmac = shaObj.getHMAC("HEX");
+    const offset = this.hex2dec(hmac.substring(hmac.length - 1));
+    let otp = (this.hex2dec(hmac.substr(offset * 2, 8)) & this.hex2dec("7fffffff")) + "";
+    const start = Math.max(otp.length - _options.digits, 0);
+    otp = otp.substring(start, start + _options.digits);
+    const expires = Math.ceil((_options.timestamp + 1) / (_options.period * 1e3)) * _options.period * 1e3;
+    return { otp, expires };
+  }
+  static hex2dec(hex) {
+    return parseInt(hex, 16);
+  }
+  static dec2hex(dec) {
+    return (dec < 15.5 ? "0" : "") + Math.round(dec).toString(16);
+  }
+  static base32tohex(base32) {
+    const base32chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    let bits = "";
+    let hex = "";
+    const _base32 = base32.replace(/=+$/, "");
+    for (let i2 = 0; i2 < _base32.length; i2++) {
+      const val = base32chars.indexOf(base32.charAt(i2).toUpperCase());
+      if (val === -1) throw new Error("Invalid base32 character in key");
+      bits += this.leftpad(val.toString(2), 5, "0");
+    }
+    for (let i2 = 0; i2 + 8 <= bits.length; i2 += 8) {
+      const chunk = bits.substr(i2, 8);
+      hex = hex + this.leftpad(parseInt(chunk, 2).toString(16), 2, "0");
+    }
+    return hex;
+  }
+  static leftpad(str, len, pad) {
+    if (len + 1 >= str.length) {
+      str = Array(len + 1 - str.length).join(pad) + str;
+    }
+    return str;
+  }
+}
+const localStorageSetItem = (name, value) => {
+  if (!isClient) return;
+  localStorage.setItem(name, value);
+};
+const localStorageGetItem = (name) => {
+  if (!isClient) return "";
+  return localStorage.getItem(name) || "";
+};
+function formatDuration(time) {
+  return time < 10 ? `0${time}` : time;
+}
+function timestampToTime(timestamp) {
+  let date = /* @__PURE__ */ new Date();
+  if (timestamp) {
+    date = new Date(timestamp);
+  }
+  date.format = (format = "YYYY-MM-DD HH:mm:ss") => {
+    const year = date.getFullYear();
+    const month = formatDuration(date.getMonth() + 1);
+    const day = formatDuration(date.getDate());
+    const hour = formatDuration(date.getHours());
+    const minute = formatDuration(date.getMinutes());
+    const second = formatDuration(date.getSeconds());
+    return format.replace(/Y+/gi, `${year}`).replace(/M+/g, `${month}`).replace(/D+/gi, `${day}`).replace(/H+/gi, `${hour}`).replace(/m+/g, `${minute}`).replace(/S+/gi, `${second}`);
+  };
+  return date;
+}
+const timeFormat = (time) => {
+  if (time === 0) return "00:00";
+  if (!time) return "";
+  const hour = Math.trunc(time / 3600);
+  const minute = Math.trunc(time % 3600 / 60);
+  const second = formatDuration(Math.trunc(time - hour * 3600 - minute * 60));
+  if (hour === 0) {
+    return `${formatDuration(minute)}:${second}`;
+  }
+  return `${formatDuration(hour)}:${formatDuration(minute)}:${second}`;
+};
+const performanceTime = () => {
+  if (typeof document !== "undefined") {
+    return performance.now();
+  }
+  if (typeof process !== "undefined") {
+    const [seconds, nanosecond] = process.hrtime();
+    return seconds * 1e3 + nanosecond / 1e6;
+  }
+  return Date.now();
+};
+const retain = (callback = noop) => {
+  const historyReturnCb = () => {
+    callback();
+    isClient && window.removeEventListener("popstate", historyReturnCb);
+  };
+  isClient && window.history.pushState(null, "", window.location.href);
+  setTimeout(() => {
+    isClient && window.addEventListener("popstate", historyReturnCb);
+  }, 500);
+};
+const getCookie = (objName) => {
+  const arrStr = document.cookie.split("; ");
+  for (let i2 = 0; i2 < arrStr.length; i2++) {
+    const item = arrStr[i2].split("=");
+    if (item[0] === objName) {
+      return decodeURIComponent(item[1]);
+    }
+  }
+  return "";
+};
+const requestUrlToBuffer = (src, options) => {
+  return new Promise(function(resolve, reject) {
+    const xhr = new XMLHttpRequest();
+    xhr.open(options.method || "GET", src, true);
+    xhr.responseType = options.responseType || "arraybuffer";
+    xhr.onload = function() {
+      if (xhr.status === 200) {
+        resolve({ success: true, data: xhr.response, message: "" });
+      } else {
+        reject({
+          success: false,
+          data: xhr.status,
+          message: `The request status is${xhr.status}`
+        });
+      }
+    };
+    xhr.onerror = function(e2) {
+      reject({ success: false, data: e2, message: `` });
+    };
+    xhr.onprogress = (event) => {
+      options.onProgress && options.onProgress(event);
+    };
+    xhr.withCredentials = options.withCredentials || false;
+    if (options.headers) {
+      Object.keys(options.headers).forEach(function(key) {
+        var _a;
+        ((_a = options.headers) == null ? void 0 : _a[key]) && xhr.setRequestHeader(key, options.headers[key]);
+      });
+    }
+    xhr.send(options.body);
+  });
+};
+const getPixelRatio = (context) => {
+  const backingStore = context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || 1;
+  return (isClient && window.devicePixelRatio || 1) / backingStore;
+};
+const createObjectURL = async (src) => {
+  if (typeof src === "string") {
+    return src;
+  } else if (src instanceof Blob) {
+    return URL.createObjectURL(src);
+  } else if (src instanceof ArrayBuffer) {
+    return URL.createObjectURL(new Blob([src]));
+  } else if (src instanceof Response) {
+    const result = await src.blob();
+    return URL.createObjectURL(result);
+  } else {
+    return src;
+  }
+};
+const getFrame = (n2 = 10) => {
+  const frameList = [];
+  let lastFrame = 0;
+  let requestAnimationFrameRef;
+  return new Promise((resolve) => {
+    const a2 = () => {
+      const now = performanceTime();
+      const frame = now - lastFrame;
+      if (lastFrame !== 0) {
+        frameList.push(frame);
+      }
+      lastFrame = now;
+      if (frameList.length > n2) {
+        const num = frameList.reduce((i2, j2) => i2 + j2);
+        resolve(1 / (num / n2));
+        cancelAnimationFrame(requestAnimationFrameRef);
+      }
+      requestAnimationFrameRef = requestAnimationFrame(a2);
+    };
+    if (frameList.length <= n2) {
+      requestAnimationFrameRef = requestAnimationFrame(a2);
+    }
+  });
+};
+const getHost = (env) => {
+  if (typeof window !== "undefined") {
+    if (env && isString(env)) ;
+    else {
+      const env2 = /\w(\.trunk|\.neibu|\.release|test)\./.exec(window.location.hostname);
+      if (env2) {
+        env2[1];
+      }
+    }
+    return "//log.chaxus.com";
+  }
+};
+const getAllQueryString = (url) => {
+  if (typeof window !== "undefined") {
+    const r2 = {};
+    const href = url || window.location.href;
+    if (href.split("?")[1]) {
+      const str = href.split("?")[1];
+      const strList = str.split("&");
+      strList.forEach((item) => {
+        const [key, val] = item.split("=");
+        if (key && val) {
+          r2[key] = decodeURIComponent(val);
+        }
+      });
+    }
+    return r2;
+  }
+  return {};
+};
+function appendUrl(url, params = {}) {
+  let _url = url;
+  if (_url.indexOf("//") === 0) {
+    _url = _url.replace("//", "https://");
+  }
+  const urlObj = new URL(_url);
+  if (params) {
+    Object.keys(params).forEach((key) => {
+      params[key] && urlObj.searchParams.set(key, params[key]);
+    });
+  }
+  return urlObj.href;
+}
+const removeGhosting = (event) => {
+  const dragIcon = document.createElement("img");
+  const url = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+  dragIcon.src = url;
+  dragIcon.width = 0;
+  dragIcon.height = 0;
+  dragIcon.style.opacity = "0";
+  if (event.dataTransfer) {
+    event.dataTransfer.setDragImage(dragIcon, 0, 0);
+  }
+};
+function getCookieByName(name) {
+  if (typeof window !== "undefined") {
+    const cookieList = document.cookie.match(new RegExp(`(^| )${name}(?:=([^;]*))?(;|$)`));
+    if (cookieList && cookieList[2]) return cookieList[2];
+  }
+  return "";
+}
+const getWindow = () => {
+  if (typeof window !== "undefined") {
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  }
+  return {
+    width: 0,
+    height: 0
+  };
+};
+const connection = () => {
+  if (typeof window !== "undefined") {
+    return window.navigator.connection;
+  }
+};
+const ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x7E]|%(?:[^\da-f]|[\da-f][^\da-f]|$))+/gi;
+const UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
+const UNMATCHED_SURROGATE_PAIR_REPLACE = "$1�$2";
+function encodeUrl(url) {
+  return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
+}
+const imageRequest = (url) => {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const startTime = (/* @__PURE__ */ new Date()).getTime();
+    img.src = url ? url : `https://github.com/favicon.ico?d=${startTime}`;
+    img.onload = () => {
+      const endTime = (/* @__PURE__ */ new Date()).getTime();
+      const delta = endTime - startTime;
+      resolve(delta);
+    };
+    img.onerror = (err) => {
+      reject(err);
+    };
+  });
+};
+const durationHandler = (handler, ...params) => (duration) => new Promise((resolve, reject) => {
+  setTimeout(async () => {
+    try {
+      const result = await handler(...params);
+      resolve(result);
+    } catch (error) {
+      reject(error);
+    }
+  }, duration);
+});
+const networkSpeed = async (options) => {
+  const { url, duration = 3e3, count = 5 } = options;
+  let jitter = 0;
+  let ping = 0;
+  const pingList = [];
+  for (let i2 = 0; i2 < count; i2++) {
+    const handler = durationHandler(imageRequest, url);
+    const delta = await handler(duration);
+    pingList.push(delta);
+  }
+  const maxPing = Math.max(...pingList);
+  const minPing = Math.min(...pingList);
+  jitter = maxPing - minPing;
+  ping = pingList.reduce((a2, b2) => a2 + b2) / pingList.length;
+  return { ping, jitter };
+};
+function compose(middleware) {
+  if (!Array.isArray(middleware)) throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function") throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(context, next) {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i2) {
+      if (i2 <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i2;
+      let fn = middleware[i2];
+      if (i2 === middleware.length && next) fn = next;
+      if (!fn) return Promise.resolve();
+      try {
+        return Promise.resolve(fn(context, dispatch.bind(null, i2 + 1)));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+const memoize = (fn) => {
+  let cache = false;
+  let result = void 0;
+  return (...args) => {
+    if (cache) {
+      return result;
+    } else {
+      result = typeof fn === "function" ? fn(...args) : fn;
+      cache = true;
+      fn = void 0;
+      return result;
+    }
+  };
+};
+function querystring(data = {}) {
+  if (typeof data !== "object") {
+    throw new TypeError("param must be object");
+  }
+  return Object.entries(data).reduce(
+    (searchParams, [name, value]) => value === void 0 || value == null ? searchParams : (searchParams.append(decodeURIComponent(name), decodeURIComponent(value)), searchParams),
+    new URLSearchParams()
+  ).toString();
+}
+const transitionJsonToString = (jsonObj, callback = (error) => {
+}) => {
+  let _jsonObj = "";
+  if (Object.prototype.toString.call(jsonObj) !== "[object String]") {
+    try {
+      _jsonObj = JSON.stringify(jsonObj);
+    } catch (error) {
+      callback(error);
+    }
+  } else {
+    try {
+      jsonObj = typeof jsonObj === "string" ? jsonObj.replace(/(')/g, '"') : JSON.stringify(jsonObj);
+      _jsonObj = JSON.stringify(JSON.parse(jsonObj));
+    } catch (error) {
+      callback(error);
+    }
+  }
+  return _jsonObj;
+};
+const formatJson = (jsonObj, callback = () => {
+}) => {
+  let formatted = "";
+  let pad = 0;
+  const PADDING = "    ";
+  let jsonString = transitionJsonToString(jsonObj, callback);
+  if (!jsonString) {
+    return jsonString;
+  }
+  const _index = [];
+  let _indexStart = null;
+  let _indexEnd = null;
+  let jsonArray = [];
+  jsonString = jsonString.replace(/([{}])/g, "\r\n$1\r\n");
+  jsonString = jsonString.replace(/([[\]])/g, "\r\n$1\r\n");
+  jsonString = jsonString.replace(/(,)/g, "$1\r\n");
+  jsonString = jsonString.replace(/(\r\n\r\n)/g, "\r\n");
+  jsonString = jsonString.replace(/\r\n,/g, ",");
+  jsonArray = jsonString.split("\r\n");
+  jsonArray.forEach(function(node, index) {
+    var _a;
+    const num = node.match(/"/g) ? ((_a = node.match(/"/g)) == null ? void 0 : _a.length) || 0 : 0;
+    if (num % 2 && !_indexStart) {
+      _indexStart = index;
+    }
+    if (num % 2 && _indexStart && _indexStart !== index) {
+      _indexEnd = index;
+    }
+    if (_indexStart && _indexEnd) {
+      _index.push({
+        start: _indexStart,
+        end: _indexEnd
+      });
+      _indexStart = null;
+      _indexEnd = null;
+    }
+  });
+  _index.reverse().forEach(function(item, index) {
+    const newArray = jsonArray.slice(item.start, item.end + 1);
+    jsonArray.splice(item.start, item.end + 1 - item.start, newArray.join(""));
+  });
+  jsonString = jsonArray.join("\r\n");
+  jsonString = jsonString.replace(/:\r\n\{/g, ":{");
+  jsonString = jsonString.replace(/:\r\n\[/g, ":[");
+  jsonArray = jsonString.split("\r\n");
+  jsonArray.forEach(function(item, index) {
+    let i2 = 0;
+    let indent = 0;
+    let padding = "";
+    if (item.match(/\{$/) || item.match(/\[$/)) {
+      indent += 1;
+    } else if (item.match(/\}$/) || item.match(/\]$/) || item.match(/\},$/) || item.match(/\],$/)) {
+      if (pad !== 0) {
+        pad -= 1;
+      }
+    } else {
+      indent = 0;
+    }
+    for (i2 = 0; i2 < pad; i2++) {
+      padding += PADDING;
+    }
+    formatted += padding + item + "\r\n";
+    pad += indent;
+  });
+  return formatted.trim();
+};
+const filterObj = (obj, list) => {
+  const result = {};
+  Object.keys(obj).forEach((item) => {
+    if (!list.includes(item)) {
+      result[item] = obj[item];
+    }
+  });
+  return result;
+};
+const merge = (a2, b2) => {
+  if (a2 && b2) {
+    for (const key in b2) {
+      a2[key] = b2[key];
+    }
+  }
+  return a2;
+};
+function replaceOld(source, name, replacement, isForced) {
+  if (typeof source === "undefined") return;
+  if (name in source || isForced) {
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (typeof wrapped === "function") {
+      source[name] = wrapped;
+    }
+  }
+}
+const mergeExports = (obj, exports) => {
+  const descriptors = Object.getOwnPropertyDescriptors(exports);
+  for (const name of Object.keys(descriptors)) {
+    const descriptor = descriptors[name];
+    if (descriptor.get) {
+      const fn = descriptor.get;
+      Object.defineProperty(obj, name, {
+        configurable: false,
+        enumerable: true,
+        get: memoize(fn)
+      });
+    } else if (typeof descriptor.value === "object") {
+      Object.defineProperty(obj, name, {
+        configurable: false,
+        enumerable: true,
+        writable: false,
+        value: mergeExports({}, descriptor.value)
+      });
+    } else {
+      throw new Error("Exposed values must be either a getter or an nested object");
+    }
+  }
+  return Object.freeze(obj);
+};
+const setAttributeByGlobal = (name, value) => {
+  if (typeof window !== "undefined") {
+    window[name] = value;
+  }
+  if (typeof global !== "undefined") {
+    global[name] = value;
+  }
+};
+const handleConsole = (hooks = noop) => {
+  const consoleTypeList = ["log", "info", "warn", "error", "assert"];
+  consoleTypeList.forEach((type) => {
+    const replacement = (originalConsole) => {
+      return function(...args) {
+        if (originalConsole) {
+          hooks(type, ...args);
+          originalConsole.apply(console, args);
+        }
+      };
+    };
+    replaceOld(console, type, replacement);
+  });
+};
+const debounce = (fn, ms = 500) => {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      fn.apply(void 0, args);
+    }, ms);
+  };
+};
+const addClassToElement = (element, addClass) => {
+  if (typeof document === "undefined") return void 0;
+  const classList = element.classList;
+  if (!classList.contains(addClass)) {
+    classList.add(addClass);
+  }
+};
+const removeClassToElement = (element, removeClass) => {
+  if (typeof document === "undefined") return void 0;
+  const classList = element.classList;
+  if (classList.contains(removeClass)) {
+    classList.remove(removeClass);
+  }
+};
+const createDocumentFragment = (list) => {
+  if (typeof document === "undefined") return void 0;
+  const Fragment = document.createDocumentFragment();
+  list.forEach((item) => Fragment.appendChild(item));
+  return Fragment;
+};
+const matchHtmlRegExp = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = matchHtmlRegExp.exec(str);
+  if (!match) {
+    return str;
+  }
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape = "&quot;";
+        break;
+      case 38:
+        escape = "&amp;";
+        break;
+      case 39:
+        escape = "&#39;";
+        break;
+      case 60:
+        escape = "&lt;";
+        break;
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escape;
+  }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+const setFontSize2html = (designWidth = 375) => {
+  let base = designWidth;
+  const { documentElement } = document;
+  const mediaQuery = window.matchMedia("(orientation: portrait)");
+  let timer;
+  let standardRatio = 667 / 375;
+  if (currentDevice() === DEVICE.IPAD) {
+    standardRatio = 1024 / 768;
+    base = 768;
+  }
+  function setFontSize() {
+    const isLandscape = !mediaQuery.matches;
+    let screenWidth = window.screen.width;
+    let screenHeight = window.screen.height;
+    if (screenWidth < screenHeight) {
+      [screenWidth, screenHeight] = [screenHeight, screenWidth];
+    }
+    let width = documentElement.clientWidth;
+    let height = screenHeight;
+    const realRatio = width / height;
+    if (realRatio >= standardRatio) {
+      width = height * standardRatio;
+      documentElement.classList.remove("adjustHeight");
+      documentElement.classList.add("adjustWidth");
+    } else {
+      height = width / standardRatio;
+      documentElement.classList.remove("adjustWidth");
+      documentElement.classList.add("adjustHeight");
+    }
+    let target = width / base * 16;
+    if (isLandscape) {
+      target /= standardRatio;
+    }
+    documentElement.style.fontSize = `${target}px`;
+    const currentSize = window.getComputedStyle(documentElement).fontSize.replace("px", "") || 0;
+    if (target !== currentSize) {
+      documentElement.style.fontSize = `${target / Number(currentSize) * target}px`;
+    }
+  }
+  window.addEventListener(
+    "resize",
+    function() {
+      clearTimeout(timer);
+      timer = setTimeout(setFontSize, 300);
+    },
+    false
+  );
+  window.addEventListener(
+    "pageshow",
+    function(e2) {
+      e2.persisted && (clearTimeout(timer), timer = setTimeout(setFontSize, 300));
+    },
+    false
+  );
+  window.addEventListener(
+    "orientationchange",
+    function() {
+      setFontSize();
+    },
+    false
+  );
+  setFontSize();
+};
+const SVG_NS = "http://www.w3.org/2000/svg";
+const SVG_TAG_NAMES = [
+  "svg",
+  "path",
+  "g",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "text",
+  "tspan",
+  "textPath",
+  "defs",
+  "marker",
+  "radialGradient",
+  "stop",
+  "linearGradient",
+  "clipPath",
+  "mask",
+  "pattern",
+  "image",
+  "use",
+  "symbol",
+  "foreignObject",
+  "feGaussianBlur",
+  "feColorMatrix"
+];
+class Chain {
+  constructor(tagName, options) {
+    __publicField(this, "listener");
+    __publicField(this, "element");
+    /**
+     * @description: 创建元素
+     * @param {string} tagName
+     * @param {ElementCreationOptions} options
+     * @return {Chain}
+     */
+    __publicField(this, "create", (tagName, options) => {
+      if (SVG_TAG_NAMES.includes(tagName)) {
+        return document.createElementNS(SVG_NS, tagName, options);
+      }
+      return document.createElement(tagName, options);
+    });
+    /**
+     * @description: 设置当前元素的属性
+     * @param {string} name
+     * @param {string} value
+     * @return {Chain}
+     */
+    __publicField(this, "setAttribute", (name, value) => {
+      this.element.setAttribute(name, value);
+      return this;
+    });
+    /**
+     * @description: 移除当前元素的属性
+     * @param {string} name
+     * @return {Chain}
+     */
+    __publicField(this, "removeAttribute", (name) => {
+      this.element.removeAttribute(name);
+      return this;
+    });
+    /**
+     * @description: 当前元素添加子元素
+     * @param {HTMLElement} child
+     * @return {ChainElement}
+     */
+    __publicField(this, "append", (child) => {
+      this.element.appendChild(child);
+      return this;
+    });
+    /**
+     * @description: 当前元素移除子元素
+     * @param {HTMLElement} child
+     * @return {Chain}
+     */
+    __publicField(this, "remove", (child) => {
+      this.element.removeChild(child);
+      return this;
+    });
+    /**
+     * @description: 给当前元素设置文本内容
+     * @param {string} text
+     * @return {Chain}
+     */
+    __publicField(this, "setTextContent", (text) => {
+      this.element.textContent = text;
+      return this;
+    });
+    /**
+     * @description: 给当前元素设置样式
+     * @param {string} name
+     * @param {string} value
+     * @return {Chain}
+     */
+    __publicField(this, "setStyle", (name, value) => {
+      this.element.style.setProperty(name, value);
+      return this;
+    });
+    /**
+     * @description: 给当前元素添加子元素
+     * @return {Chain}
+     */
+    __publicField(this, "addChild", (child) => {
+      if (Array.isArray(child)) {
+        const Fragment = document.createDocumentFragment();
+        child.forEach((item) => Fragment.appendChild(item.element));
+        this.element.appendChild(Fragment);
+      } else {
+        this.element.appendChild(child.element);
+      }
+      return this;
+    });
+    /**
+     * @description: 给当前元素添加事件监听
+     * @param {string} type
+     * @param {EventListener} listener
+     * @return {Chain}
+     */
+    __publicField(this, "listen", (type, listener, options) => {
+      let event = this.listener.get(type);
+      if (!event) {
+        event = /* @__PURE__ */ new Map();
+        this.listener.set(type, event);
+      }
+      const value = event.get(listener.name);
+      if (value === listener) {
+        console.warn(`${value.name} listener has been added to ${type} event, please remove it first.`);
+      }
+      this.element.addEventListener(type, listener, options);
+      event.set(listener.name, listener);
+      return this;
+    });
+    /**
+     * @description: 移除当前元素的事件监听
+     * @param {string} type
+     * @return {Chain}
+     */
+    __publicField(this, "clearListener", (type, listener, options) => {
+      this.element.removeEventListener(type, listener, options);
+      const event = this.listener.get(type);
+      if (event) {
+        event.delete(listener.name);
+      } else {
+        console.warn(`No ${type} event listener has been added.`);
+      }
+      return this;
+    });
+    /**
+     * @description: 移除当前元素的所有事件监听
+     * @return {Chain}
+     */
+    __publicField(this, "clearAllListener", () => {
+      for (const [key, value] of this.listener) {
+        for (const [k2, v2] of value) {
+          this.element.removeEventListener(key, v2);
+          value.delete(k2);
+        }
+        this.listener.delete(key);
+      }
+      return this;
+    });
+    this.element = this.create(tagName, options);
+    this.listener = /* @__PURE__ */ new Map();
+  }
+}
+const create = (tagName, options) => {
+  return new Chain(tagName, options);
+};
+const handleError = (hooks = noop) => {
+  if (typeof window !== "undefined") {
+    window.addEventListener(
+      "unhandledrejection",
+      (error) => {
+        hooks(error);
+      },
+      true
+    );
+    window.addEventListener(
+      "error",
+      (error) => {
+        hooks(error);
+        return false;
+      },
+      true
+    );
+  }
+};
+const isImageSize = (file, width, height) => {
+  return new Promise((resolve, reject) => {
+    if (!isClient) reject("window is undefined");
+    const _URL = window.URL || window.webkitURL;
+    const img = new Image();
+    img.onload = function() {
+      let valid = false;
+      if (width) {
+        valid = img.width === width;
+      }
+      if (height) {
+        valid = img.height === height;
+      }
+      _URL.revokeObjectURL(img.src);
+      resolve(valid);
+    };
+    img.src = _URL.createObjectURL(file);
+  });
+};
+const convertImageToBase64 = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = function() {
+      resolve({ success: true, data: reader.result, message: "" });
+    };
+    reader.onerror = (e2) => {
+      reject({ success: false, data: e2, message: "" });
+    };
+    reader.readAsDataURL(file);
+  });
+};
+function getPerformance() {
+  if (typeof window !== "undefined") {
+    const [performanceNavigationTiming] = performance.getEntriesByType("navigation");
+    const [firstPaint = {}, firstContentfulPaint = {}] = performance.getEntriesByType("paint");
+    const { startTime: fp } = firstPaint;
+    const { startTime: fcp } = firstContentfulPaint;
+    const {
+      domainLookupEnd,
+      domainLookupStart,
+      connectEnd,
+      connectStart,
+      secureConnectionStart,
+      loadEventStart,
+      domInteractive,
+      domContentLoadedEventEnd,
+      duration,
+      responseStart,
+      requestStart,
+      responseEnd,
+      fetchStart,
+      transferSize,
+      encodedBodySize,
+      redirectEnd,
+      redirectStart,
+      redirectCount
+    } = performanceNavigationTiming;
+    return {
+      // DNS
+      dnsSearch: domainLookupEnd - domainLookupStart,
+      // TCP
+      tcpConnect: connectEnd - connectStart,
+      sslConnect: connectEnd - secureConnectionStart,
+      request: responseStart - requestStart,
+      response: responseEnd - responseStart,
+      parseDomTree: domInteractive - responseEnd,
+      resource: loadEventStart - domContentLoadedEventEnd,
+      domReady: domContentLoadedEventEnd - fetchStart,
+      interactive: domInteractive - fetchStart,
+      complete: loadEventStart - fetchStart,
+      httpHead: transferSize - encodedBodySize,
+      redirect: redirectCount,
+      // redirect
+      redirectTime: redirectEnd - redirectStart,
+      duration,
+      fp,
+      fcp
+    };
+  }
+}
+const sendBeacon = ({ url = "", type = "application/json; charset=UTF-8", payload = {} }) => {
+  const requestUrl = url ? url : getHost();
+  if (navigator.sendBeacon && requestUrl) {
+    const param = new Blob([JSON.stringify(payload)], { type });
+    return navigator.sendBeacon(requestUrl, param);
+  }
+};
+const sendImage = ({ url = "", payload = {} }) => {
+  const requestUrl = url ? url : getHost();
+  if (typeof document !== "undefined" && requestUrl) {
+    const image = new Image();
+    image.width = 1;
+    image.height = 1;
+    image.src = `${requestUrl}?${querystring(payload)}`;
+  }
+};
+const report = ({
+  url = "",
+  type = "application/json; charset=UTF-8",
+  payload = {}
+}) => {
+  const requestUrl = url ? url : getHost();
+  if (typeof navigator !== "undefined") {
+    return sendBeacon({ url: requestUrl, type, payload });
+  }
+  return sendImage({ url: requestUrl, payload });
+};
+function createData(params = {}) {
+  if (typeof window !== "undefined") {
+    const { width, height } = getWindow();
+    return Object.assign(
+      {},
+      {
+        id: randomString(),
+        path: window.location.href,
+        time: Date.now(),
+        referrer: document.referrer,
+        ip: window.returnCitySN || { cid: "", cip: "", cname: "" },
+        userId: getCookie("chaxus_prod"),
+        ratio: `${width}x${height}`,
+        userAgent: window.navigator.userAgent
+      },
+      params
+    );
+  }
+  return {};
+}
+const handleFetchHook = (options = {}) => {
+  if (typeof window !== "undefined") {
+    const { requestHook = noop, responseHook = noop, errorHook = noop } = options;
+    const replacement = (originalFetch) => {
+      return (url, config) => {
+        requestHook(url, config);
+        return originalFetch.apply(window, [url, config]).then((response) => {
+          responseHook(url, config, response);
+          return response;
+        }).catch((error) => {
+          errorHook(url, error);
+          throw error;
+        });
+      };
+    };
+    replaceOld(window, "fetch", replacement);
+  }
+};
+const handleXhrHook = (options = {}) => {
+  if (typeof window !== "undefined") {
+    const originalXhrProto = XMLHttpRequest.prototype;
+    const { requestHook = noop, responseHook = noop, errorHook = noop } = options;
+    const replacementXhrOpen = (originalOpen) => {
+      return function(...args) {
+        requestHook(args);
+        originalOpen.apply(this, args);
+      };
+    };
+    replaceOld(originalXhrProto, "open", replacementXhrOpen);
+    const replacementXhrSend = (originalSend) => {
+      return function(...args) {
+        this.addEventListener("loadend", function() {
+          responseHook(this);
+        });
+        this.addEventListener("error", function() {
+          errorHook(this);
+        });
+        originalSend.apply(this, args);
+      };
+    };
+    replaceOld(originalXhrProto, "send", replacementXhrSend);
+  }
+};
+const throttle = (fn, wait = 300) => {
+  let timer;
+  return function() {
+    const context = this;
+    const args = arguments;
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        fn.apply(context, args);
+      }, wait);
+    }
+  };
+};
+const generateThrottle = () => {
+  let timer;
+  return function(fn, wait = 300) {
+    return function(...args) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      const context = this;
+      if (!timer) {
+        timer = setTimeout(() => {
+          fn.apply(context, args);
+          clearTimeout(timer);
+          timer = void 0;
+        }, wait);
+      }
+    };
+  };
+};
+const requestAnimation = (fn) => {
+  if (!isClient) return;
+  let ticking = false;
+  return function() {
+    const context = this;
+    const args = arguments;
+    if (!ticking) {
+      window.requestAnimationFrame(function() {
+        fn.apply(context, args);
+        ticking = false;
+      });
+      ticking = true;
+    }
+  };
+};
+class Monitor {
+  constructor() {
+    __publicField(this, "init", () => {
+      this.reportClick();
+      this.reportError();
+      this.reportFetch();
+      this.reportPerformance();
+      this.reportXhr();
+    });
+    this.initialize();
+  }
+  /**
+   * @description: 页面加载性能上报
+   * @param {Payload} param1
+   */
+  reportPerformance() {
+    const params = getPerformance();
+    const payload = createData();
+    report({
+      payload: {
+        ...params,
+        ...payload
+      }
+    });
+  }
+  /**
+   * @description: 手动触发的上报
+   * @param {Record} payload
+   * @param {*} unknown
+   */
+  log(payload) {
+    report({ payload });
+  }
+  /**
+   * @description: 点击上报
+   * @return {*}
+   */
+  reportClick() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const hook = (event) => {
+      const { pageX, pageY, screenX, screenY, type } = event;
+      throttleReport({
+        payload: {
+          ...payload,
+          data: { pageX, pageY, screenX, screenY, type },
+          type: "click"
+        }
+      });
+    };
+    handleClick(hook);
+  }
+  // ajax 上报
+  reportXhr() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const requestHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "xhrRequest" }
+      });
+    };
+    const responseHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "xhrResponse" }
+      });
+    };
+    const errorHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "xhrError" }
+      });
+    };
+    handleXhrHook({ requestHook, responseHook, errorHook });
+  }
+  /**
+   * @description: fetch上报
+   */
+  reportFetch() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const requestHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "fetchRequest" }
+      });
+    };
+    const responseHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "fetchResponse" }
+      });
+    };
+    const errorHook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "fetchError" }
+      });
+    };
+    handleFetchHook({ requestHook, responseHook, errorHook });
+  }
+  /**
+   * @description: 错误上报
+   */
+  reportError() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const hook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "error" }
+      });
+    };
+    handleError(hook);
+  }
+  /**
+   * @description: 上报console
+   */
+  reportConsole() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const hook = (...args) => {
+      throttleReport({
+        payload: { ...payload, data: { ...args }, type: "console" }
+      });
+    };
+    handleConsole(hook);
+  }
+  initialize() {
+    if (typeof window !== "undefined" && !window.ranlog) {
+      window.ranlog = true;
+      this.init();
+    }
+    if (typeof process !== "undefined" && !process.ranlog) {
+      process.ranlog = true;
+      this.init();
+    }
+  }
+}
+const codes = /* @__PURE__ */ new Map([
+  [100, "Continue"],
+  [101, "Switching Protocols"],
+  [102, "Processing"],
+  [103, "Early Hints"],
+  [200, "OK"],
+  [201, "Created"],
+  [202, "Accepted"],
+  [203, "Non-Authoritative Information"],
+  [204, "No Content"],
+  [205, "Reset Content"],
+  [206, "Partial Content"],
+  [207, "Multi-Status"],
+  [208, "Already Reported"],
+  [226, "IM Used"],
+  [300, "Multiple Choices"],
+  [301, "Moved Permanently"],
+  [302, "Found"],
+  [303, "See Other"],
+  [304, "Not Modified"],
+  [305, "Use Proxy"],
+  [307, "Temporary Redirect"],
+  [308, "Permanent Redirect"],
+  [400, "Bad Request"],
+  [401, "Unauthorized"],
+  [402, "Payment Required"],
+  [403, "Forbidden"],
+  [404, "Not Found"],
+  [405, "Method Not Allowed"],
+  [406, "Not Acceptable"],
+  [407, "Proxy Authentication Required"],
+  [408, "Request Timeout"],
+  [409, "Conflict"],
+  [410, "Gone"],
+  [411, "Length Required"],
+  [412, "Precondition Failed"],
+  [413, "Payload Too Large"],
+  [414, "URI Too Long"],
+  [415, "Unsupported Media Type"],
+  [416, "Range Not Satisfiable"],
+  [417, "Expectation Failed"],
+  [418, "I'm a Teapot"],
+  [421, "Misdirected Request"],
+  [422, "Unprocessable Entity"],
+  [423, "Locked"],
+  [424, "Failed Dependency"],
+  [425, "Too Early"],
+  [426, "Upgrade Required"],
+  [428, "Precondition Required"],
+  [429, "Too Many Requests"],
+  [431, "Request Header Fields Too Large"],
+  [451, "Unavailable For Legal Reasons"],
+  [500, "Internal Server Error"],
+  [501, "Not Implemented"],
+  [502, "Bad Gateway"],
+  [503, "Service Unavailable"],
+  [504, "Gateway Timeout"],
+  [505, "HTTP Version Not Supported"],
+  [506, "Variant Also Negotiates"],
+  [507, "Insufficient Storage"],
+  [508, "Loop Detected"],
+  [509, "Bandwidth Limit Exceeded"],
+  [510, "Not Extended"],
+  [511, "Network Authentication Required"]
+]);
+const status = {
+  // status code to message map
+  message: codes,
+  // status message (lower-case) to code map
+  code: createMessageToStatusCodeMap(codes),
+  // array of status codes
+  codes: createStatusCodeList(codes),
+  // status codes for redirects
+  redirect: {
+    300: true,
+    301: true,
+    302: true,
+    303: true,
+    305: true,
+    307: true,
+    308: true
+  },
+  // status codes for empty bodies
+  empty: {
+    204: true,
+    205: true,
+    304: true
+  },
+  // status codes for when you should retry the request
+  retry: {
+    502: true,
+    503: true,
+    504: true
+  }
+};
+function createMessageToStatusCodeMap(codes2) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [status2, message] of codes2) {
+    map.set(message.toLowerCase(), status2);
+  }
+  return map;
+}
+function createStatusCodeList(codes2) {
+  const codeList = [];
+  for (const [status2, _] of codes2) {
+    codeList.push(status2);
+  }
+  return codeList;
+}
+function getStatusCode(message) {
+  const msg = message.toLowerCase();
+  status.code.has(msg);
+  if (!status.code.has(msg)) {
+    throw new Error('invalid status message: "' + message + '"');
+  }
+  return status.code.get(msg);
+}
+function getStatusMessage(code) {
+  if (!status.message.has(code)) {
+    throw new Error("invalid status code: " + code);
+  }
+  return status.message.get(code);
+}
+function getStatus(code) {
+  if (typeof code === "number") {
+    return getStatusMessage(code);
+  }
+  if (typeof code !== "string") {
+    throw new TypeError("code must be a number or string");
+  }
+  const n2 = parseInt(code, 10);
+  if (!isNaN(n2) && status.codes.includes(n2)) {
+    return getStatusMessage(n2);
+  }
+  return getStatusCode(code);
+}
+const perToNum = (str = "") => {
+  if (str.length === 0) return 0;
+  if (str.endsWith("%")) {
+    const value = Number(str.replace("%", ""));
+    return value > 1 ? value / 100 : value;
+  } else {
+    return Number(str);
+  }
+};
+const range = (num, min = 0, max = 1) => {
+  return Math.min(max, Math.max(min, num));
+};
+const _Mathjs = class _Mathjs {
+  constructor() {
+    /**
+     * 获取数字小数点的长度
+     * @param {number} n 数字
+     */
+    __publicField(this, "getDecimalLength", (n2) => {
+      const [_, decimal] = n2.toString().split(".");
+      return decimal ? decimal.length : 0;
+    });
+    __publicField(this, "amend", (n2, precision = 15) => parseFloat(Number(n2).toPrecision(precision)));
+    __publicField(this, "power", (a2, b2) => Math.pow(10, Math.max(this.getDecimalLength(a2), this.getDecimalLength(b2))));
+  }
+};
+__publicField(_Mathjs, "handleMethod", (l2, r2) => {
+  const mathjs2 = new _Mathjs();
+  const { power, amend } = mathjs2;
+  const pow = power(l2, r2);
+  const a2 = amend(l2 * pow);
+  const b2 = amend(r2 * pow);
+  return (type) => {
+    switch (type) {
+      case "+":
+        return (a2 + b2) / pow;
+      case "-":
+        return (a2 - b2) / pow;
+      case "*":
+        return a2 * b2 / (pow * pow);
+      case "/":
+        return a2 / b2;
+    }
+  };
+});
+__publicField(_Mathjs, "add", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("+");
+});
+__publicField(_Mathjs, "divide", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("/");
+});
+__publicField(_Mathjs, "multiply", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("*");
+});
+__publicField(_Mathjs, "subtract", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("-");
+});
+let Mathjs = _Mathjs;
+function mathjs(a2, type, b2) {
+  function getDecimalLength(n2) {
+    const [_, decimal] = n2.toString().split(".");
+    return decimal ? decimal.length : 0;
+  }
+  const amend = (n2, precision = 15) => parseFloat(Number(n2).toPrecision(precision));
+  const power = Math.pow(10, Math.max(getDecimalLength(a2), getDecimalLength(b2)));
+  let result = 0;
+  a2 = amend(a2 * power);
+  b2 = amend(b2 * power);
+  switch (type) {
+    case "+":
+      result = (a2 + b2) / power;
+      break;
+    case "-":
+      result = (a2 - b2) / power;
+      break;
+    case "*":
+      result = a2 * b2 / (power * power);
+      break;
+    case "/":
+      result = a2 / b2;
+      break;
+  }
+  result = amend(result);
+  return {
+    /** 计算结果 */
+    result,
+    /**
+     * 继续计算
+     * @param {"+"|"-"|"*"|"/"} nextType 继续计算方式
+     * @param {number} nextValue 继续计算的值
+     */
+    next: (nextType, nextValue) => {
+      return mathjs(result, nextType, nextValue);
+    }
+  };
+}
+class QuestQueue {
+  constructor({ simultaneous, total }) {
+    __publicField(this, "current");
+    __publicField(this, "queue");
+    __publicField(this, "simultaneous");
+    // 并发的请求
+    __publicField(this, "executed");
+    __publicField(this, "total");
+    /**
+     * @description: 传入异步函数，添加到队列并执行
+     * @param {Fun} asynchronous
+     * @return {*}
+     */
+    __publicField(this, "add", (asynchronous) => {
+      if (typeof asynchronous !== "function") return;
+      const task = () => {
+        return new Promise((resolve, reject) => {
+          this.current++;
+          asynchronous().then(resolve).catch(reject).finally(() => {
+            this.current--;
+            this.running();
+          });
+        });
+      };
+      this.queue.push(task);
+    });
+    /**
+     * @description: 执行异步函数
+     * @param {*} Promise
+     * @return {*}
+     */
+    __publicField(this, "running", () => {
+      return new Promise((resolve, reject) => {
+        if (this.current <= this.simultaneous && this.queue.length) {
+          const task = this.queue.pop();
+          if (task) {
+            task().then(resolve).catch(reject).finally(() => {
+              this.executed++;
+            });
+          }
+        } else {
+          resolve({});
+        }
+      });
+    });
+    /**
+     * @description: 并发执行所有的异步函数，并返回所有的结果
+     * @param {*} Promise
+     * @return {*}
+     */
+    __publicField(this, "allSettled", () => {
+      let index = 0;
+      return new Promise((resolve, reject) => {
+        const result = [];
+        if (this.current < this.simultaneous && this.queue.length) {
+          const task = this.queue.pop();
+          index++;
+          if (task) {
+            task().then((x) => {
+              result[index] = x;
+              resolve(x);
+            }).catch((x) => {
+              result[index] = x;
+              reject(x);
+            }).finally(() => {
+              this.executed++;
+            });
+          }
+        }
+        if (this.executed >= this.total) {
+          resolve(result);
+        }
+      });
+    });
+    this.current = 0;
+    this.queue = [];
+    this.simultaneous = simultaneous;
+    this.executed = 0;
+    this.total = total;
+  }
+}
+const scriptOnLoad = (urls, append, callback) => {
+  urls = Array.isArray(urls) ? urls : [urls];
+  const array = urls.map((src) => {
+    const cssReg = /\w*.css$/;
+    let script;
+    if (cssReg.test(src)) {
+      const link = document.createElement("link");
+      link.type = "text/css";
+      link.rel = "stylesheet";
+      link.href = src;
+      script = link;
+    } else {
+      script = document.createElement("script");
+      script.type = "text/javascript";
+      script.src = src;
+    }
+    const bodyElement = document.getElementsByTagName("body")[0];
+    const currentAppend = append || bodyElement;
+    currentAppend.appendChild(script);
+    return new Promise((resolve) => {
+      script.onload = () => {
+        resolve();
+      };
+    });
+  });
+  return new Promise((resolve) => {
+    Promise.all(array).then(() => {
+      if (typeof callback === "function") {
+        callback();
+      }
+      resolve();
+    });
+  });
+};
+const NEW_LISTENER = "NEW_LISTENER";
+class SyncHook {
+  constructor() {
+    __publicField(this, "_events");
+    /**
+     * @description: 订阅事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    __publicField(this, "tap", (eventName, eventItem) => {
+      if (this._events[eventName] && eventName !== Symbol.for(NEW_LISTENER)) {
+        this.call(Symbol.for(NEW_LISTENER), eventName);
+      }
+      const callbacks = this._events[eventName] || [];
+      if (typeof eventItem === "function") {
+        callbacks.push({
+          name: eventName,
+          callback: eventItem
+        });
+      } else {
+        callbacks.push(eventItem);
+      }
+      this._events[eventName] = callbacks;
+      return this;
+    });
+    /**
+     * @description: 触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {void}
+     */
+    __publicField(this, "call", (eventName, ...args) => {
+      const callbacks = this._events[eventName] || [];
+      callbacks.forEach((item) => {
+        const { callback } = item;
+        callback(...args);
+      });
+    });
+    /**
+     * @description: 同步触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {Promise<void>}
+     */
+    __publicField(this, "callSync", async (eventName, ...args) => {
+      const callbacks = this._events[eventName] || [];
+      for (const item of callbacks) {
+        const { callback } = item;
+        await callback(...args);
+      }
+    });
+    /**
+     * @description: 只订阅一次事件，触发后就移除事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    __publicField(this, "once", (eventName, eventItem) => {
+      let one;
+      if (typeof eventItem === "function") {
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            eventItem(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: eventItem
+        };
+      } else {
+        const { callback } = eventItem;
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            callback(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: callback
+        };
+      }
+      this.tap(eventName, one);
+      return this;
+    });
+    /**
+     * @description: 移除订阅的事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    __publicField(this, "off", (eventName, eventItem) => {
+      const callbacks = this._events[eventName] || [];
+      const newCallbacks = callbacks.filter((item) => {
+        if (typeof eventItem === "function") {
+          return item.callback !== eventItem && item.initialCallback !== eventItem;
+        } else {
+          const { callback } = eventItem;
+          return item.callback !== callback && item.initialCallback !== callback;
+        }
+      });
+      this._events[eventName] = newCallbacks;
+      return this;
+    });
+    this._events = {};
+  }
+}
+export {
+  AudioRecorder,
+  Chain,
+  C as Color,
+  a as ColorScheme,
+  F as FMT,
+  H as Hsl,
+  b as Hsla,
+  Mathjs,
+  M as MimeType,
+  Monitor,
+  QuestQueue,
+  R as Rgb,
+  c as Rgba,
+  SyncHook,
+  TOTP,
+  addClassToElement,
+  appendUrl,
+  audioVendor,
+  canvasVendor,
+  d as changeHumpToLowerCase,
+  e as clearBr,
+  f as clearStr,
+  g as componentToHex,
+  compose,
+  connection,
+  convertImageToBase64,
+  create,
+  createData,
+  createDocumentFragment,
+  createObjectURL,
+  currentDevice,
+  debounce,
+  durationHandler,
+  encodeUrl,
+  escapeHtml,
+  filterObj,
+  formatJson,
+  generateThrottle,
+  getAllQueryString,
+  getCookie,
+  getCookieByName,
+  getFrame,
+  getHost,
+  h as getMime,
+  getPerformance,
+  getPixelRatio,
+  getStatus,
+  getWindow,
+  handleConsole,
+  handleError,
+  handleFetchHook,
+  i as hexToRgb,
+  j as hsbToRgb,
+  k as hslToRgb,
+  l as hsvToHsl,
+  m as hsvToRgb,
+  n as hue2rgb,
+  imageRequest,
+  isBangDevice,
+  isClient,
+  isImageSize,
+  isMobile,
+  isString,
+  isWeiXin,
+  localStorageGetItem,
+  localStorageSetItem,
+  mathjs,
+  memoize,
+  merge,
+  mergeExports,
+  networkSpeed,
+  noop,
+  perToNum,
+  performanceTime,
+  querystring,
+  r as randomColor,
+  randomString,
+  range,
+  removeClassToElement,
+  removeGhosting,
+  replaceOld,
+  report,
+  requestAnimation,
+  requestUrlToBuffer,
+  retain,
+  q as rgbToHex,
+  s as rgbToHsb,
+  t as rgbToHsl,
+  scriptOnLoad,
+  setAttributeByGlobal,
+  setFontSize2html,
+  u as setMime,
+  status,
+  v as str2Xml,
+  w as strParse,
+  throttle,
+  timeFormat,
+  timestampToTime,
+  webglVendor
+};