cap-widget 0.1.46

package/src/worker.js

@@ -0,0 +1,198 @@
+(() => {
+  const solveFallback = async ({ salt, target }) => {
+    let nonce = 0;
+    const batchSize = 50000;
+    const encoder = new TextEncoder();
+
+    const targetBits = target.length * 4;
+    const fullBytes = Math.floor(targetBits / 8);
+    const remainingBits = targetBits % 8;
+
+    const paddedTarget = target.length % 2 === 0 ? target : target + "0";
+    const targetBytesLength = paddedTarget.length / 2;
+    const targetBytes = new Uint8Array(targetBytesLength);
+    for (let k = 0; k < targetBytesLength; k++) {
+      targetBytes[k] = parseInt(paddedTarget.substring(k * 2, k * 2 + 2), 16);
+    }
+
+    const partialMask = remainingBits > 0 ? (0xff << (8 - remainingBits)) & 0xff : 0;
+
+    while (true) {
+      try {
+        for (let i = 0; i < batchSize; i++) {
+          const inputString = salt + nonce;
+          const inputBytes = encoder.encode(inputString);
+
+          const hashBuffer = await crypto.subtle.digest("SHA-256", inputBytes);
+
+          const hashBytes = new Uint8Array(hashBuffer);
+
+          let matches = true;
+
+          for (let k = 0; k < fullBytes; k++) {
+            if (hashBytes[k] !== targetBytes[k]) {
+              matches = false;
+              break;
+            }
+          }
+
+          if (matches && remainingBits > 0) {
+            if ((hashBytes[fullBytes] & partialMask) !== (targetBytes[fullBytes] & partialMask)) {
+              matches = false;
+            }
+          }
+
+          if (matches) {
+            self.postMessage({ nonce, found: true });
+            return;
+          }
+
+          nonce++;
+        }
+      } catch (error) {
+        console.error("[cap worker]", error);
+        self.postMessage({
+          found: false,
+          error: error.message,
+        });
+        return;
+      }
+    }
+  };
+
+  if (typeof WebAssembly !== "object" || typeof WebAssembly?.instantiate !== "function") {
+    console.warn(
+      "[cap worker] wasm not supported, falling back to alternative solver. this will be significantly slower.",
+    );
+
+    self.onmessage = async ({ data: { salt, target } }) => {
+      return solveFallback({ salt, target });
+    };
+
+    return;
+  }
+
+  let solve_pow_function = null;
+
+  const initFromModule = (wasmModule) => {
+    try {
+      let wasm;
+      let WASM_VECTOR_LEN = 0;
+      let cachedUint8ArrayMemory = null;
+
+      const getMemory = () => {
+        if (cachedUint8ArrayMemory === null || cachedUint8ArrayMemory.byteLength === 0) {
+          cachedUint8ArrayMemory = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachedUint8ArrayMemory;
+      };
+
+      const encoder = new TextEncoder();
+
+      const passStringToWasm = (str, malloc, realloc) => {
+        if (realloc === undefined) {
+          const encoded = encoder.encode(str);
+          const ptr = malloc(encoded.length, 1) >>> 0;
+          getMemory()
+            .subarray(ptr, ptr + encoded.length)
+            .set(encoded);
+          WASM_VECTOR_LEN = encoded.length;
+          return ptr;
+        }
+
+        let len = str.length;
+        let ptr = malloc(len, 1) >>> 0;
+        const mem = getMemory();
+        let offset = 0;
+
+        for (; offset < len; offset++) {
+          const code = str.charCodeAt(offset);
+          if (code > 127) break;
+          mem[ptr + offset] = code;
+        }
+
+        if (offset !== len) {
+          if (offset !== 0) str = str.slice(offset);
+          ptr = realloc(ptr, len, (len = offset + str.length * 3), 1) >>> 0;
+          const subarray = getMemory().subarray(ptr + offset, ptr + len);
+          const { written } = encoder.encodeInto(str, subarray);
+          offset += written;
+          ptr = realloc(ptr, len, offset, 1) >>> 0;
+        }
+
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+      };
+
+      const imports = { wbg: {} };
+      imports.wbg.__wbindgen_init_externref_table = () => {
+        const table = wasm.__wbindgen_export_0;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+      };
+
+      const instance = new WebAssembly.Instance(wasmModule, imports);
+      wasm = instance.exports;
+
+      if (wasm.__wbindgen_start) wasm.__wbindgen_start();
+
+      solve_pow_function = (salt, target) => {
+        const saltPtr = passStringToWasm(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const saltLen = WASM_VECTOR_LEN;
+        const targetPtr = passStringToWasm(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const targetLen = WASM_VECTOR_LEN;
+        return BigInt.asUintN(64, wasm.solve_pow(saltPtr, saltLen, targetPtr, targetLen));
+      };
+
+      return true;
+    } catch (e) {
+      console.error("[cap worker] failed to init wasm from module:", e);
+      return false;
+    }
+  };
+
+  self.onmessage = async ({ data: { salt, target, wasmModule } }) => {
+    if (wasmModule instanceof WebAssembly.Module && solve_pow_function === null) {
+      const ok = initFromModule(wasmModule);
+      if (!ok) {
+        console.warn("[cap worker] wasm init failed, falling back to JS solver.");
+        return solveFallback({ salt, target });
+      }
+    }
+
+    if (solve_pow_function === null) {
+      console.warn("[cap worker] no wasm module provided, falling back to JS solver.");
+      return solveFallback({ salt, target });
+    }
+
+    try {
+      const startTime = performance.now();
+      const nonce = solve_pow_function(salt, target);
+      const endTime = performance.now();
+
+      self.postMessage({
+        nonce: Number(nonce),
+        found: true,
+        durationMs: (endTime - startTime).toFixed(2),
+      });
+    } catch (error) {
+      console.error("[cap worker]", error);
+
+      self.postMessage({
+        found: false,
+        error: error.message || String(error),
+      });
+    }
+  };
+
+  self.onerror = (error) => {
+    self.postMessage({
+      found: false,
+      error,
+    });
+  };
+})();

package/wasm-hashes.min.js

@@ -0,0 +1,327 @@
+!((e, t) => {
+  "object" == typeof exports && "undefined" != typeof module
+    ? t(exports)
+    : "function" == typeof define && define.amd
+      ? define(["exports"], t)
+      : t(
+          ((e = "undefined" != typeof globalThis ? globalThis : e || self).hashwasm =
+            e.hashwasm || {}),
+        );
+})(void 0, (e) => {
+  function t(e, t, n, A) {
+    return new (n || (n = Promise))((i, o) => {
+      function r(e) {
+        try {
+          a(A.next(e));
+        } catch (e) {
+          o(e);
+        }
+      }
+      function E(e) {
+        try {
+          a(A.throw(e));
+        } catch (e) {
+          o(e);
+        }
+      }
+      function a(e) {
+        var t;
+        e.done
+          ? i(e.value)
+          : ((t = e.value),
+            t instanceof n
+              ? t
+              : new n((e) => {
+                  e(t);
+                })).then(r, E);
+      }
+      a((A = A.apply(e, t || [])).next());
+    });
+  }
+  "function" == typeof SuppressedError && SuppressedError;
+  class n {
+    constructor() {
+      this.mutex = Promise.resolve();
+    }
+    lock() {
+      let e = () => {};
+      return (
+        (this.mutex = this.mutex.then(() => new Promise(e))),
+        new Promise((t) => {
+          e = t;
+        })
+      );
+    }
+    dispatch(e) {
+      return t(this, void 0, void 0, function* () {
+        const t = yield this.lock();
+        try {
+          return yield Promise.resolve(e());
+        } finally {
+          t();
+        }
+      });
+    }
+  }
+  var A;
+  const i =
+      "undefined" != typeof globalThis
+        ? globalThis
+        : "undefined" != typeof self
+          ? self
+          : "undefined" != typeof window
+            ? window
+            : global,
+    o = null !== (A = i.Buffer) && void 0 !== A ? A : null,
+    r = i.TextEncoder ? new i.TextEncoder() : null;
+  function E(e, t) {
+    return (
+      (((15 & e) + ((e >> 6) | ((e >> 3) & 8))) << 4) | ((15 & t) + ((t >> 6) | ((t >> 3) & 8)))
+    );
+  }
+  const a = "a".charCodeAt(0) - 10,
+    g = "0".charCodeAt(0);
+  function s(e, t, n) {
+    let A = 0;
+    for (let i = 0; i < n; i++) {
+      let n = t[i] >>> 4;
+      ((e[A++] = n > 9 ? n + a : n + g), (n = 15 & t[i]), (e[A++] = n > 9 ? n + a : n + g));
+    }
+    return String.fromCharCode.apply(null, e);
+  }
+  const C =
+      null !== o
+        ? (e) => {
+            if ("string" == typeof e) {
+              const t = o.from(e, "utf8");
+              return new Uint8Array(t.buffer, t.byteOffset, t.length);
+            }
+            if (o.isBuffer(e)) return new Uint8Array(e.buffer, e.byteOffset, e.length);
+            if (ArrayBuffer.isView(e)) return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+            throw new Error("Invalid data type!");
+          }
+        : (e) => {
+            if ("string" == typeof e) return r.encode(e);
+            if (ArrayBuffer.isView(e)) return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+            throw new Error("Invalid data type!");
+          },
+    B = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+    c = new Uint8Array(256);
+  for (let e = 0; e < 64; e++) c[B.charCodeAt(e)] = e;
+  function l(e) {
+    const t = ((e) => {
+        let t = Math.floor(0.75 * e.length);
+        const n = e.length;
+        return ("=" === e[n - 1] && ((t -= 1), "=" === e[n - 2] && (t -= 1)), t);
+      })(e),
+      n = e.length,
+      A = new Uint8Array(t);
+    let i = 0;
+    for (let t = 0; t < n; t += 4) {
+      const n = c[e.charCodeAt(t)],
+        o = c[e.charCodeAt(t + 1)],
+        r = c[e.charCodeAt(t + 2)],
+        E = c[e.charCodeAt(t + 3)];
+      ((A[i] = (n << 2) | (o >> 4)),
+        (i += 1),
+        (A[i] = ((15 & o) << 4) | (r >> 2)),
+        (i += 1),
+        (A[i] = ((3 & r) << 6) | (63 & E)),
+        (i += 1));
+    }
+    return A;
+  }
+  const h = 16384,
+    f = new n(),
+    d = new Map();
+  function u(e, n) {
+    return t(this, void 0, void 0, function* () {
+      let A = null,
+        i = null,
+        o = !1;
+      if ("undefined" == typeof WebAssembly)
+        throw new Error("WebAssembly is not supported in this environment!");
+      const r = () => new DataView(A.exports.memory.buffer).getUint32(A.exports.STATE_SIZE, !0),
+        a = f.dispatch(() =>
+          t(this, void 0, void 0, function* () {
+            if (!d.has(e.name)) {
+              const t = l(e.data),
+                n = WebAssembly.compile(t);
+              d.set(e.name, n);
+            }
+            const t = yield d.get(e.name);
+            A = yield WebAssembly.instantiate(t, {});
+          }),
+        ),
+        g = () => {
+          const e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : null;
+          ((o = !0), A.exports.Hash_Init(e));
+        },
+        B = (e) => {
+          if (!o) throw new Error("update() called before init()");
+          ((e) => {
+            let t = 0;
+            for (; t < e.length; ) {
+              const n = e.subarray(t, t + h);
+              ((t += n.length), i.set(n), A.exports.Hash_Update(n.length));
+            }
+          })(C(e));
+        },
+        c = new Uint8Array(2 * n),
+        u = (e) => {
+          const t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : null;
+          if (!o) throw new Error("digest() called before init()");
+          return ((o = !1), A.exports.Hash_Final(t), "binary" === e ? i.slice(0, n) : s(c, i, n));
+        },
+        v = (e) => ("string" == typeof e ? e.length < 4096 : e.byteLength < h);
+      let N = v;
+      switch (e.name) {
+        case "argon2":
+        case "scrypt":
+          N = () => !0;
+          break;
+        case "blake2b":
+        case "blake2s":
+          N = (e, t) => t <= 512 && v(e);
+          break;
+        case "blake3":
+          N = (e, t) => 0 === t && v(e);
+          break;
+        case "xxhash64":
+        case "xxhash3":
+        case "xxhash128":
+          N = () => !1;
+      }
+      return (
+        yield (() =>
+          t(this, void 0, void 0, function* () {
+            A || (yield a);
+            const e = A.exports.Hash_GetBuffer(),
+              t = A.exports.memory.buffer;
+            i = new Uint8Array(t, e, h);
+          }))(),
+        {
+          getMemory: () => i,
+          writeMemory: (e) => {
+            const t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
+            i.set(e, t);
+          },
+          getExports: () => A.exports,
+          setMemorySize: (e) => {
+            A.exports.Hash_SetMemorySize(e);
+            const t = A.exports.Hash_GetBuffer(),
+              n = A.exports.memory.buffer;
+            i = new Uint8Array(n, t, e);
+          },
+          init: g,
+          update: B,
+          digest: u,
+          save: () => {
+            if (!o) throw new Error("save() can only be called after init() and before digest()");
+            const t = A.exports.Hash_GetState(),
+              n = r(),
+              i = A.exports.memory.buffer,
+              a = new Uint8Array(i, t, n),
+              g = new Uint8Array(4 + n);
+            return (
+              ((e, t) => {
+                const n = t.length >> 1;
+                for (let A = 0; A < n; A++) {
+                  const n = A << 1;
+                  e[A] = E(t.charCodeAt(n), t.charCodeAt(n + 1));
+                }
+              })(g, e.hash),
+              g.set(a, 4),
+              g
+            );
+          },
+          load: (t) => {
+            if (!(t instanceof Uint8Array))
+              throw new Error("load() expects an Uint8Array generated by save()");
+            const n = A.exports.Hash_GetState(),
+              i = r(),
+              a = 4 + i,
+              g = A.exports.memory.buffer;
+            if (t.length !== a)
+              throw new Error(
+                "Bad state length (expected ".concat(a, " bytes, got ").concat(t.length, ")"),
+              );
+            if (
+              !((e, t) => {
+                if (e.length !== 2 * t.length) return !1;
+                for (let n = 0; n < t.length; n++) {
+                  const A = n << 1;
+                  if (t[n] !== E(e.charCodeAt(A), e.charCodeAt(A + 1))) return !1;
+                }
+                return !0;
+              })(e.hash, t.subarray(0, 4))
+            )
+              throw new Error("This state was written by an incompatible hash implementation");
+            const s = t.subarray(4);
+            (new Uint8Array(g, n, i).set(s), (o = !0));
+          },
+          calculate: (e) => {
+            const t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : null,
+              o = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : null;
+            if (!N(e, t)) return (g(t), B(e), u("hex", o));
+            const r = C(e);
+            return (i.set(r), A.exports.Hash_Calculate(r.length, t, o), s(c, i, n));
+          },
+          hashLength: n,
+        }
+      );
+    });
+  }
+  let v =
+    "AGFzbQE||BEAF/YAF/AG|AGACf38|wgH|EBAQ
Aw$AQECAgYOAn8BQfCJBQt/AEGACAsHcAgGbWVtb3J5AÔHZXRCdWZmZX
|lº0luaXQ|Qtº1VwZGF0ZQACCkhhc2hfRmluYWwABA1º0dldFN0YXRl|UÔDYWxjdWxhdGUABgpTVEFURV9TSVpFAwEKoEoHBQBBkLnQEABCADcDwÈBHEEg
BB4AFGIbNgL#QFBAEKnn+anxvST/b5/Qquzj/yRo7Pw2wABs3A+C“QrGWgP6fooWs6ABC/6S5iMWR2oKbfy|GzcD2ÈCl7rDg5Onlod3QvLmu+Ojp/2npX8Bs3A9C“Qti9loj8oLW+NkLnzKfQ1tDrs7t/
AbNwPI¥L7wICAX4Gf0EAApA8CJAS
CtfDcDw`AkACQAJA
GnQT9xIgINAEGACSEDDAELAkBBw|msiBC|
QEkbIgNFDQA0EDcSEF
JBg`aiEGAhAgJA
NBBEkNACADQfwAcSEHAhAgNA
Ym#AyACQYAJ˜DFq
JBgQ¿NBAmokGCCÀ0ED\vCQYMJ˜H
JBBG#AkcN|sL
VFDQADQCAG
Jq
JB¿JBAWohAiAFQX9gUN|sL
QEsNAU»y|
RrIQAgBEGACWohAwsCQC|Qc|SQ0|0AxAD
NBwABQMEFAai
QT9LDQALCy|RQ0AAhAkÊUDQCACQYCJAWoyAC˜CFQICAFFgVB/wFxSw0ACwsLoz4BRX9BAC|KAI8IgFËU¡AB‰$§FBGXc$OA$̶OCICÏJ?k±
JÒC\vµg!R>BE£BE}¶HF\vµE!Z>Bk£Bk}¶AH\vµk!hq
JAk=Ak\bgN hgCÜK[K]µU‚tq
J hADE™M[M]µM‚1 jADmo¶CCIJÏl?gC$Idk<
lÒPÝ9-
9.
Z igEGo$PBB{C$PJJ{E$PRR{EkEPSS{E2o¶NCIUh0R?gFE±RÒV•V-V.
5qJ iwiFÜW[W]Q\vR\vIÝh-
h.
Rq
lq
V>B$OB$ÌgCmoÇC0™L[L]M\vV\vNÝ1-
1.
9qZq
NA0=A0\bhRFE=FE\bhdF0=F0\bhÂlGÉGU\bhpGk=Gk\bhtG0=G0\bhx>HE£HE}ÜC[C]V\vY\vOÝ5-
5.ZqdqB>EE£EE}gCGogFGogE0EPTT{H$Pdd{HkEPee{H—E0™T[T]Y\vDÝN-
N.
Fqlq9H0=H0\biBqJ>Ek£Ek}gF—H—E$ZR[R]U\ve\vJÝl-
l.
Nq1qxHE=HE\biFIÉIU\biJIk=Ik\biNI0=I0\biRqt>G0£G0}gH¢I—GÜa[a]d\vi\vZ•l-l.NCFqh>GE£GE}ÍHGogF0™X[X]R\vb\vU•R-R.
lqpCBIE=IE\biVJÉJU\biZJk=Jk\bidJ0=J0\bihKE=KE\bilKÉKU\bipKk=Kk\bit>K0£K0}gH0™f[f]b\vn\ve•5-5.pCZq1>H$OH$ÌgGÇJÇJEEPkk{LEEPss{L$Ptt{L¢JE™k[k]n\vg¸B-ICB.xChC5Lk=Lk\bi9CN>I0£I0}gJ¢L¢IÜi[i]l\vt\vh¸F-ICF.ICBCxCtK0=K0\bjBME=ME\bjFMÉMU\bjJMk=Mk\bjNCp>Kk£Kk}gLÇM¢K$Zp[p]s\vx\vo¸h-ICh.ICRDBCd>J0£J0}gI—K—JÜm[m]i\vq\vl¸V-ICV.ICFClC9L0=L0\bjRNE=NE\bjVNÉNU\bjZNk=Nk\bjdN0=N0\bjhOE=OE\bjlOÉOU\bjogOCA0IC4gLCAhsgG,D
4gBE‘Y¥iO0ª7(7d3c0‘k¥iPGp–4`Ij1–3`Ij5zIDtxID1z\vHakGY36iUBG#B0‘U¥iP2#ACAM\v7
1D4gD—P,G\vAID4gO3NxID5z\vA¦
B
BGRid2JB2#QE‘Q¥iQW#DC|IDtœ7Ãz/eDrntkJ–z`IkNg0gDC|c3EHNq
1%D$VDUaW3181+aiJE·siJAS
P
0gDHÙxŽHbhNvKA2#RSBBIEMHNxIEMHÚB®EETAEE«
dgZgdq
UgD—CiAN\vL
xq
cgDyAN†DX‹fGjxM8FK
YHMgQ3EgBi|€pIX+kXlgs¼A×P
Q¨ŽHVvfHYem#QC*ER½E†BH‹ZjVnsB9aiJCš’RW#DG#BÇFiAH\vQ
9q
ggBGogB,Ö$aF(FgbaNlAFgg¼N^\vKNP
U¨ŽG+i8ahAm#Di*q
t½F†BX‹cP7sagFQš€9Lr5lQdhY¼N×F\vB
Rq
IgB—F,P\vF
Q¨z\vF¦
V
VH+4/qGeG#By*q
hÐgYgB,E†BHNq
Z%BkEVBkaeN8N55E
EÕ,N…DmÛ#DCAG
VœFÃ9OLvjHxgUÎNQDN
wgBnÙZz\vN¦
1
1HB0+2kfm#CC\tZÐg8gF—E,N\vU
xq
kgB¢DyAN
xœMD0ªP(Pho/5/X5gYHCJ
8gDXÙ1³HGu4b+AG#DC
R¯EgC,P†D3~czDsqACNBW#AW#FCßÄ79ik7wJg8ICX\vTRqgŸEiAJ\vXQÁX¦ddGqidLTBG#GC
ZgNgkgFyAU†FH©dzTwuUFUDG°,JdœXÅ2pHmtwdhcNC&HSovnBeW#GS
9¯Nq4ÍGiAR\vd;e2Mx8F6aGG#AWƒyM+MgHthgUCHH/+X6e2#FCdgN@fOXgLd8XGW°—ICAS\vcFq8_x6KerX1àHRxqk2a
:G#A2„59KkoQFhgUai&GFldy9Am#FCABdgJhMgI—JiAS\viFCU_uMLs8AJ؁H827HpBG#GS\tp›ZOa4JkFa\fGG1OapqAZhg‡UDT\voJCQŸJyAJ\v)G7laizB2#FC\tdgFŒa6Si454X\fGWۄhdnIk3lhk‡aD&Gh0f+Vem#Gi\thÐhNCoÍL,R\vp;cvM6cB6Y\fFGۃ8JauknxhQ‡XDGjo7G7fG#Fy\tlgF@ZnQy4x9Z\fGmÛ#E—MCAS\vvFCs_pIzktH1ho‡YDGF67igf2#GC\tR›fDAqoMBU\fF2loKTzQFØTIDZDIÍN,R\vx;YjY3fEBZGm#AWƒzO6hugJhoYCG1+cKlA2#GCRgN@bOZ8MgDUF2°—LE™s[s]o\v0\vz93IDN¬IDN­XJDcŸMyAJ\v)HK1OL2BG#GyABlgJŒc+U89wFZ
:m#A2„89+5wQZhoYai&Huhb6kB2#HCABRgJhNC5>Lk£Lk}gK¢N¢L$Zt[t]p\v1\vX93d¬d­U93R¬R­YJDkŸFCAJ\v)HvxpXFB2#CSt¯E¾~ZTwoaZ4bGW°iARNœTÆiISc5nhà)H6//uFeW#Gix¯QgPGo2AuS“ID8Jaitg:W#AaJajYC1`AgP,v¸9-IC9.ICtDdqÂgŸFCATJœSÄ69nBonphkW#EWo2AuC“IEEgC,DCc,J
NxJ¹l”lž\vZaiajYC0`AgPiAw•IDB-IDB.IC9qdDpOk=Ok\bBJqEgFCAT†E3~ffH5vd7X
JhJqNgLcCBD
EgCXM3E,J…F2Ûo2Asy“IDsgNE™0[0]w\v4\vY93h¬h­\vT\vSEgFHNxR´Hy8cWzfG#E,Damo2Ati“
AÎJRamo2AsiJAQu2BgIEfwF+·sCJAS
J29xIgFÞC
IoAgBBfy|N0IgB0QX9zcUG|,AdHM2ACQAJ|kA$OSQ0|kA$ORw0ABBADYCv`C0»0ÊMMAQs$NRg0B
FBAWohAwsyE|kBBBiADa0EHcSICRQ0A
NÞaiEB
Mh|NA
FBADYCACABRQEEEBaiEA
JBf2#Ag0ACws0F5akEHSQ0A
BBAnQhAQNA
FBmŠkŠiŠgŠIG#A$4Rw0ACwtBACEBBBACkDw`IgSnIgBBG3QEELdEGAgPwHcXIEEFdk<
BBA3RˆjYCv`AgBEIdiKc2AriJAU»0EA·uS 5Ȗ4gE‘c¥2Aty“·ti 2Ȗ1UE‘Q¥2AtC“·sy zȖyI¥CQE‘#QEiAkUNAEÊADQCABQYAJ\vBQciJAÀ$BaiEB
IEEBai
Qf8BcUsN|sLCwYAQYCJAQujAQBBAE
NwPAEEcQ,UHUYiARs2Aui“Qqef5qfG9JP9vn9Cq7OP/JGjs/DbACABGzcD4ÈCsZaA/p+ihazoAEL/pLmIxZHagpt/
EbNwPYEKXusODk6eWh3dC8ua746On/aelfyABGzcD0ÈC2L2WiPygtb42QufMp9DW0Ouzu38Rs3A8iJA,AÊBAsLCwEAQYAICwRw||
IAd3MgcyA
MnMXEyACcXM0EeDÑDÓ,DCc,B
NxB¹F”Fž\vAC
ÚÙIXÚJ®kETAkE«c,C
FxC¹J”Jž\v\bEKdnN\tAD
Jz
Fx
MnÚN®0ETA0E«\vaiA\f
E3MnE,D…d3c2pBIBBD3cgBB3dzakiC$YdCAJ¤l²Jh2cnIiiAEEYdC|¤B²Ah2cnIaiIgAQQdyAEHd3NqQyACBc,D
JxD¹N”Nž\vqI
Nz
Jx
E3ÚF®$TA$«c—`IgBËE¡|‰EEYdnJyNgLQRBFXdz JAS
ÏB?E±
BˆjYC!IgNË0¡AD‰0E§#oi$UE%BGncg&SEgCXÙl´(V3)TIÁT¦NN*AN
xz
Zx
0gDHÚ1BHncgD$TD$Kd3N,SA-BDndz.BA3Zz:IXM3EÎcXMkEeCÑCÓG;
lqMgEiAR†EXNqN%E0EVE0<GA/gNx=EN>BGXcg?BgP4Dc$IdHI@hIgE,J†CXNqJ%EkEVEk[53]N2^c,M
ZxM¹x”xž_gCÇEyASFœRE0ªT(T`IkB{p2c2#|AA}EÌ~NqF%E$VEUR
kgE3NxNz\vR¦FF€’QG#DG#BCAÖEªE(EJMgEnNxJ³‚IglËgCU¡AJ‰gC$§ƒ#C,TJœSC$aJ(J„#E,JNœTŅcXM$eBÑBӆc3Eg‡ÎDˆBGHZyc‰h2QYD+A3EŠ`ak
Nw

FB‹Nq
d%B0EVB0Œgk¾©Û#EißƎz\vP¦
9
9CIDÏN?0±
NҐ13‘EAKAL’cXMgBkEeGÑGӓJA$A”BE3dz
•l3–BACgC—2og˜ai0|Do|CA™EZš
YÕgBiAN›ÐhEgC,T†E3~œzc,iQFBAžBCndzŸgEÇ q
AoA¡<h0ci¢mog£EO¤QYD+A3FBCHRy
¥iQE¦p3§YdnJyIg¨gB3Ùd©Nq
l%C$VCUªEa«Kd3Nq¬BDXdz­BCnZz®BHnc¯gNh°#AW#E±EIdk<²BCHZBgP4Dc,³z\vJ¦
l
l´z\vS¦JJµAKAI¶CgC·AoA¸•IC¹53
ºIYXNoX»GA¥QA¼gDCAG½gZgcgDyA¾gEyAS†En¿lqLQ|OA
ÀWot|A6|AÁgEXNxFz\vÂhGE=GE\bhÃDEªM(MÄFEªU(UÅE$aR(RÆEkªS(SÇWogÈ`BÉ$NÊEAIQËBGHQÌDdnMÍgE¢ÎiABÏh0
ÐgFÑN3҈iIÓp3ÔOSGFzaF9ÕgDXMgDHEÖH
9œPB×^aiBCNØhc‡ZDÙNx
ÚFz
Û#AmÜk™Ý•
ÞBAnRBg`ßAR
lœJàhkaC";
+  const N =
+    "àßÞÝÜÛÚÙØ×ÖÕÔÓÒÑÐÏÎÍÌËÊÉÈÇÆÅÄÃÂÁÀ¿¾½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥¤£¢¡ Ÿžœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…„ƒ‚€~}|{`_^][@?>=<;:.-,*)(&%$#! \f\v\t\b
";
+  let D;
+  for (D in N) {
+    const e = v.split(N[D]);
+    v = e.join(e.pop());
+  }
+  var G = { name: "sha256", data: v, hash: "64f06674" };
+  const y = new n();
+  let J = null;
+  ((e.createSHA256 = () =>
+    u(G, 32).then((e) => {
+      e.init(256);
+      const t = {
+        init: () => (e.init(256), t),
+        update: (n) => (e.update(n), t),
+        digest: (t) => e.digest(t),
+        save: () => e.save(),
+        load: (n) => (e.load(n), t),
+        blockSize: 64,
+        digestSize: 32,
+      };
+      return t;
+    })),
+    (e.sha256 = (e) => {
+      if (null === J)
+        return (function (e, n) {
+          return t(this, void 0, void 0, function* () {
+            const t = yield e.lock(),
+              A = yield u(n, 32);
+            return (t(), A);
+          });
+        })(y, G).then((t) => ((J = t), J.calculate(e, 256)));
+      try {
+        const t = J.calculate(e, 256);
+        return Promise.resolve(t);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }));
+});
+
+console.warn(
+  `[cap]
+%cYou're using a deprecated version of Cap's widget that still relies on this file.
+
+It may continue to work for now, but could break at any time since this dependency was removed several versions ago.
+
+Please update Cap to fix this.`,
+  "font-size:15px;background-image:url('https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fpreview.colorkit.co%2Fcolor%2FEEEEEE.png%3Ftype%3Darticle-preview-logo%26size%3Dsocial%26colorname%3DSuper%2520Silver&f=1&nofb=1&ipt=49845e9195461b7c779182793c2ebf7834102eaf5561c15fa2cbb55494b77a9b');background-size:10px",
+);