@time-file/browser-file-crypto 1.0.3 → 1.1.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const k = 16, G = 12, C = 256, U = 1e5, M = 32, v = 1, V = 2, B = 16, W = 45, x = 29, l = "AES-GCM", N = "SHA-256", T = {
+const J = 16, P = 12, X = 256, ee = 1e5, te = 32, ne = 1, re = 2, ae = 17, ce = 18, ie = 65536, se = 1, oe = 16, Ee = 45, le = 29, _ = "AES-GCM", k = "SHA-256", C = {
   INVALID_INPUT: "Input must be a File, Blob, or ArrayBuffer.",
   PASSWORD_REQUIRED: "Password or keyfile is required for encryption.",
   KEYFILE_REQUIRED: "Keyfile is required to decrypt this file.",
@@ -10,47 +10,47 @@ const k = 16, G = 12, C = 256, U = 1e5, M = 32, v = 1, V = 2, B = 16, W = 45, x
   DOWNLOAD_FAILED: "File download failed.",
   UNSUPPORTED_FORMAT: "Unsupported encryption format."
 };
-class p extends Error {
+class o extends Error {
   /**
    * Creates a new CryptoError.
    *
    * @param code - Error code identifying the type of error
    * @param message - Optional custom message (defaults to predefined message)
    */
-  constructor(a, t) {
-    super(t ?? T[a]), this.name = "CryptoError", this.code = a, Error.captureStackTrace && Error.captureStackTrace(this, p);
+  constructor(a, e) {
+    super(e ?? C[a]), this.name = "CryptoError", this.code = a, Error.captureStackTrace && Error.captureStackTrace(this, o);
   }
 }
-function j(n) {
-  return n instanceof p;
+function ue(n) {
+  return n instanceof o;
 }
-async function s(n) {
+async function w(n) {
   if (n instanceof ArrayBuffer)
     return n;
   if (n instanceof Blob)
     return n.arrayBuffer();
-  throw new p("INVALID_INPUT");
+  throw new o("INVALID_INPUT");
 }
-function o(n) {
+function h(n) {
   return n.buffer.slice(n.byteOffset, n.byteOffset + n.byteLength);
 }
-function L(n) {
+function Y(n) {
   const a = new Uint8Array(n);
-  let t = "";
-  for (let e = 0; e < a.byteLength; e++)
-    t += String.fromCharCode(a[e]);
-  return btoa(t);
-}
-function _(n) {
-  const a = atob(n), t = new Uint8Array(a.length);
-  for (let e = 0; e < a.length; e++)
-    t[e] = a.charCodeAt(e);
-  return t.buffer;
-}
-async function A(n, a) {
-  const t = new TextEncoder(), e = await crypto.subtle.importKey(
+  let e = "";
+  for (let t = 0; t < a.byteLength; t++)
+    e += String.fromCharCode(a[t]);
+  return btoa(e);
+}
+function O(n) {
+  const a = atob(n), e = new Uint8Array(a.length);
+  for (let t = 0; t < a.length; t++)
+    e[t] = a.charCodeAt(t);
+  return e.buffer;
+}
+async function T(n, a) {
+  const e = new TextEncoder(), t = await crypto.subtle.importKey(
     "raw",
-    t.encode(n),
+    e.encode(n),
     "PBKDF2",
     !1,
     ["deriveKey"]
@@ -58,278 +58,472 @@ async function A(n, a) {
   return crypto.subtle.deriveKey(
     {
       name: "PBKDF2",
-      salt: o(a),
+      salt: h(a),
       iterations: 1e5,
-      hash: N
+      hash: k
     },
-    e,
-    { name: l, length: 256 },
+    t,
+    { name: _, length: 256 },
     !1,
     // non-extractable for security
     ["encrypt", "decrypt"]
   );
 }
-async function w(n) {
+async function I(n) {
   try {
-    const a = _(n);
+    const a = O(n);
     return await crypto.subtle.importKey(
       "raw",
       a,
-      { name: l, length: 256 },
+      { name: _, length: 256 },
       !1,
       // non-extractable for security
       ["encrypt", "decrypt"]
     );
   } catch {
-    throw new p("INVALID_KEYFILE");
+    throw new o("INVALID_KEYFILE");
   }
 }
-function u(n) {
+function S(n) {
   return crypto.getRandomValues(new Uint8Array(n));
 }
-function R() {
-  return u(16);
+function M() {
+  return S(16);
 }
-function I() {
-  return u(12);
+function N() {
+  return S(12);
 }
-const h = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*", D = 16;
-function Z(n = D) {
-  const a = Math.max(8, Math.min(128, n)), t = u(a);
-  let e = "";
-  for (let i = 0; i < a; i++) {
-    const c = t[i] % h.length;
-    e += h[c];
+const L = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*", U = 16;
+function ye(n = U) {
+  const a = Math.max(8, Math.min(128, n)), e = S(a);
+  let t = "";
+  for (let r = 0; r < a; r++) {
+    const c = e[r] % L.length;
+    t += L[c];
   }
-  return e;
+  return t;
 }
-async function Q(n, a) {
-  const { password: t, keyData: e, onProgress: i } = a;
-  if (!t && !e)
-    throw new p("PASSWORD_REQUIRED");
+async function pe(n, a) {
+  const { password: e, keyData: t, onProgress: r } = a;
+  if (!e && !t)
+    throw new o("PASSWORD_REQUIRED");
   try {
-    i == null || i({ phase: "deriving_key", progress: 0 });
-    const c = await s(n);
-    return i == null || i({ phase: "deriving_key", progress: 10 }), e ? await m(c, e, i) : await S(c, t, i);
+    r == null || r({ phase: "deriving_key", progress: 0 });
+    const c = await w(n);
+    return r == null || r({ phase: "deriving_key", progress: 10 }), t ? await H(c, t, r) : await F(c, e, r);
   } catch (c) {
-    throw c instanceof p ? c : new p("ENCRYPTION_FAILED");
+    throw c instanceof o ? c : new o("ENCRYPTION_FAILED");
   }
 }
-async function S(n, a, t) {
-  const e = R(), i = I();
-  t == null || t({ phase: "deriving_key", progress: 20 });
-  const c = await A(a, e);
-  t == null || t({ phase: "encrypting", progress: 30 });
-  const r = await crypto.subtle.encrypt(
-    { name: l, iv: o(i) },
+async function F(n, a, e) {
+  const t = M(), r = N();
+  e == null || e({ phase: "deriving_key", progress: 20 });
+  const c = await T(a, t);
+  e == null || e({ phase: "encrypting", progress: 30 });
+  const i = await crypto.subtle.encrypt(
+    { name: _, iv: h(r) },
     c,
     n
   );
-  t == null || t({ phase: "encrypting", progress: 90 });
-  const y = new Uint8Array(
-    29 + r.byteLength
+  e == null || e({ phase: "encrypting", progress: 90 });
+  const s = new Uint8Array(
+    29 + i.byteLength
   );
-  return y[0] = 1, y.set(e, 1), y.set(i, 17), y.set(new Uint8Array(r), 29), t == null || t({ phase: "complete", progress: 100 }), new Blob([y], { type: "application/octet-stream" });
+  return s[0] = 1, s.set(t, 1), s.set(r, 17), s.set(new Uint8Array(i), 29), e == null || e({ phase: "complete", progress: 100 }), new Blob([s], { type: "application/octet-stream" });
 }
-async function m(n, a, t) {
-  const e = I();
-  t == null || t({ phase: "deriving_key", progress: 20 });
-  const i = await w(a);
-  t == null || t({ phase: "encrypting", progress: 30 });
+async function H(n, a, e) {
+  const t = N();
+  e == null || e({ phase: "deriving_key", progress: 20 });
+  const r = await I(a);
+  e == null || e({ phase: "encrypting", progress: 30 });
   const c = await crypto.subtle.encrypt(
-    { name: l, iv: o(e) },
-    i,
+    { name: _, iv: h(t) },
+    r,
     n
   );
-  t == null || t({ phase: "encrypting", progress: 90 });
-  const r = new Uint8Array(13 + c.byteLength);
-  return r[0] = 2, r.set(e, 1), r.set(new Uint8Array(c), 13), t == null || t({ phase: "complete", progress: 100 }), new Blob([r], { type: "application/octet-stream" });
+  e == null || e({ phase: "encrypting", progress: 90 });
+  const i = new Uint8Array(13 + c.byteLength);
+  return i[0] = 2, i.set(t, 1), i.set(new Uint8Array(c), 13), e == null || e({ phase: "complete", progress: 100 }), new Blob([i], { type: "application/octet-stream" });
 }
-async function O(n, a) {
-  const { password: t, keyData: e, onProgress: i } = a;
+async function V(n, a) {
+  const { password: e, keyData: t, onProgress: r } = a;
   try {
-    i == null || i({ phase: "decrypting", progress: 0 });
-    const c = new Uint8Array(await s(n));
-    if (i == null || i({ phase: "decrypting", progress: 5 }), c.length < 1)
-      throw new p("INVALID_ENCRYPTED_DATA");
-    const r = c[0];
-    if (r === 1) {
-      if (!t)
-        throw new p("PASSWORD_REQUIRED");
-      return await b(c, t, i);
-    } else if (r === 2) {
+    r == null || r({ phase: "decrypting", progress: 0 });
+    const c = new Uint8Array(await w(n));
+    if (r == null || r({ phase: "decrypting", progress: 5 }), c.length < 1)
+      throw new o("INVALID_ENCRYPTED_DATA");
+    const i = c[0];
+    if (i === 1) {
       if (!e)
-        throw new p("KEYFILE_REQUIRED");
-      return await K(c, e, i);
+        throw new o("PASSWORD_REQUIRED");
+      return await v(c, e, r);
+    } else if (i === 2) {
+      if (!t)
+        throw new o("KEYFILE_REQUIRED");
+      return await G(c, t, r);
     } else
-      throw new p("UNSUPPORTED_FORMAT");
+      throw new o("UNSUPPORTED_FORMAT");
   } catch (c) {
-    throw c instanceof p ? c : new p("DECRYPTION_FAILED");
+    throw c instanceof o ? c : new o("DECRYPTION_FAILED");
   }
 }
-async function b(n, a, t) {
+async function v(n, a, e) {
   if (n.length < 45)
-    throw new p("INVALID_ENCRYPTED_DATA");
-  t == null || t({ phase: "deriving_key", progress: 10 });
-  const e = n.slice(1, 17), i = n.slice(17, 29), c = n.slice(29), r = await A(a, e);
-  t == null || t({ phase: "decrypting", progress: 30 });
+    throw new o("INVALID_ENCRYPTED_DATA");
+  e == null || e({ phase: "deriving_key", progress: 10 });
+  const t = n.slice(1, 17), r = n.slice(17, 29), c = n.slice(29), i = await T(a, t);
+  e == null || e({ phase: "decrypting", progress: 30 });
   try {
-    const y = await crypto.subtle.decrypt(
-      { name: l, iv: o(i) },
-      r,
+    const s = await crypto.subtle.decrypt(
+      { name: _, iv: h(r) },
+      i,
       c
     );
-    return t == null || t({ phase: "complete", progress: 100 }), new Blob([y]);
+    return e == null || e({ phase: "complete", progress: 100 }), new Blob([s]);
   } catch {
-    throw new p("INVALID_PASSWORD");
+    throw new o("INVALID_PASSWORD");
   }
 }
-async function K(n, a, t) {
+async function G(n, a, e) {
   if (n.length < 29)
-    throw new p("INVALID_ENCRYPTED_DATA");
-  t == null || t({ phase: "decrypting", progress: 10 });
-  const e = n.slice(1, 13), i = n.slice(13), c = await w(a);
-  t == null || t({ phase: "decrypting", progress: 30 });
+    throw new o("INVALID_ENCRYPTED_DATA");
+  e == null || e({ phase: "decrypting", progress: 10 });
+  const t = n.slice(1, 13), r = n.slice(13), c = await I(a);
+  e == null || e({ phase: "decrypting", progress: 30 });
   try {
-    const r = await crypto.subtle.decrypt(
-      { name: l, iv: o(e) },
+    const i = await crypto.subtle.decrypt(
+      { name: _, iv: h(t) },
       c,
-      i
+      r
     );
-    return t == null || t({ phase: "complete", progress: 100 }), new Blob([r]);
+    return e == null || e({ phase: "complete", progress: 100 }), new Blob([i]);
   } catch {
-    throw new p("INVALID_KEYFILE");
+    throw new o("INVALID_KEYFILE");
+  }
+}
+function K(n, a) {
+  const e = new Uint8Array(12);
+  e.set(n);
+  const t = new DataView(e.buffer), r = t.getUint32(8, !0);
+  return t.setUint32(8, r ^ a, !0), e;
+}
+function b(n, a) {
+  const e = new Uint8Array(n.length + a.length);
+  return e.set(n, 0), e.set(a, n.length), e;
+}
+async function m(n, a, e, t) {
+  const r = K(e, t), c = await crypto.subtle.encrypt(
+    { name: _, iv: h(r) },
+    a,
+    h(n)
+  ), i = new Uint8Array(4 + c.byteLength);
+  return new DataView(i.buffer).setUint32(0, c.byteLength, !0), i.set(new Uint8Array(c), 4), i;
+}
+async function W(n, a, e, t) {
+  const r = K(e, t);
+  try {
+    const c = await crypto.subtle.decrypt(
+      { name: _, iv: h(r) },
+      a,
+      h(n)
+    );
+    return new Uint8Array(c);
+  } catch {
+    throw new o("DECRYPTION_FAILED");
+  }
+}
+function B(n, a, e, t) {
+  if (n && e) {
+    const r = new Uint8Array(34);
+    return r[0] = 17, r[1] = 1, new DataView(r.buffer).setUint32(2, a, !0), r.set(e, 6), r.set(t, 22), r;
+  } else {
+    const r = new Uint8Array(18);
+    return r[0] = 18, r[1] = 1, new DataView(r.buffer).setUint32(2, a, !0), r.set(t, 6), r;
+  }
+}
+function g(n) {
+  const a = n[0], e = a === 17;
+  if (a !== 17 && a !== 18)
+    throw new o("UNSUPPORTED_FORMAT");
+  const t = n[1];
+  if (t !== 1)
+    throw new o("UNSUPPORTED_FORMAT");
+  const r = new DataView(n.buffer, n.byteOffset).getUint32(
+    2,
+    !0
+  );
+  if (e) {
+    const c = n.slice(6, 22), i = n.slice(22, 34);
+    return { isPassword: e, version: t, chunkSize: r, salt: c, baseIV: i, headerSize: 34 };
+  } else {
+    const c = n.slice(6, 18);
+    return { isPassword: e, version: t, chunkSize: r, salt: null, baseIV: c, headerSize: 18 };
   }
 }
-async function g(n) {
-  const a = await s(n), t = new Uint8Array(a);
-  if (t.length < 1)
+async function x(n) {
+  const { password: a, keyData: e, chunkSize: t = 65536, onProgress: r } = n;
+  if (!a && !e)
+    throw new o("PASSWORD_REQUIRED");
+  const c = !!a, i = c ? M() : null, s = N();
+  r == null || r({
+    phase: "deriving_key",
+    processedBytes: 0,
+    processedChunks: 0
+  });
+  const u = c ? await T(a, i) : await I(e), l = B(c, t, i, s);
+  let E = new Uint8Array(0), y = 0, R = 0;
+  return { stream: new TransformStream({
+    async transform(d, p) {
+      for (E = b(E, d); E.length >= t; ) {
+        const A = E.slice(0, t);
+        E = E.slice(t);
+        const f = await m(A, u, s, y);
+        p.enqueue(f), y++, R += A.length, r == null || r({
+          phase: "processing",
+          processedBytes: R,
+          processedChunks: y
+        });
+      }
+    },
+    async flush(d) {
+      if (E.length > 0) {
+        const p = await m(E, u, s, y);
+        d.enqueue(p), R += E.length, y++;
+      }
+      r == null || r({
+        phase: "complete",
+        processedBytes: R,
+        processedChunks: y,
+        progress: 100
+      });
+    }
+  }), header: l };
+}
+function z(n) {
+  const { password: a, keyData: e, onProgress: t } = n;
+  let r = new Uint8Array(0), c = !1, i = null, s = null, u = 0, l = 0, E = !1, y = 0;
+  return new TransformStream({
+    async transform(R, D) {
+      if (r = b(r, R), !c) {
+        if (r.length < 2) return;
+        const p = r[0] === 17 ? 34 : 18;
+        if (r.length < p) return;
+        const A = r.slice(0, p), f = g(A);
+        if (E = f.isPassword, s = f.baseIV, y = f.headerSize, E && !a)
+          throw new o("PASSWORD_REQUIRED");
+        if (!E && !e)
+          throw new o("KEYFILE_REQUIRED");
+        t == null || t({
+          phase: "deriving_key",
+          processedBytes: 0,
+          processedChunks: 0
+        }), i = E ? await T(a, f.salt) : await I(e), r = r.slice(y), c = !0;
+      }
+      for (; r.length >= 4; ) {
+        const p = 4 + new DataView(
+          r.buffer,
+          r.byteOffset
+        ).getUint32(0, !0);
+        if (r.length < p) break;
+        const A = r.slice(4, p);
+        r = r.slice(p);
+        const f = await W(A, i, s, u);
+        D.enqueue(f), l += f.length, u++, t == null || t({
+          phase: "processing",
+          processedBytes: l,
+          processedChunks: u
+        });
+      }
+    },
+    async flush() {
+      if (r.length > 0)
+        throw new o("INVALID_ENCRYPTED_DATA");
+      t == null || t({
+        phase: "complete",
+        processedBytes: l,
+        processedChunks: u,
+        progress: 100
+      });
+    }
+  });
+}
+async function fe(n, a) {
+  const e = n.size, t = a.onProgress ? (E) => {
+    a.onProgress({
+      ...E,
+      totalBytes: e,
+      progress: E.phase === "complete" ? 100 : Math.round(E.processedBytes / e * 100)
+    });
+  } : void 0, { stream: r, header: c } = await x({
+    ...a,
+    onProgress: t
+  }), s = n.stream().pipeThrough(r);
+  let u = !1;
+  const l = s.getReader();
+  return new ReadableStream({
+    async pull(E) {
+      if (!u) {
+        E.enqueue(c), u = !0;
+        return;
+      }
+      try {
+        const { done: y, value: R } = await l.read();
+        y ? E.close() : E.enqueue(R);
+      } catch (y) {
+        E.error(y);
+      }
+    },
+    cancel() {
+      l.releaseLock();
+    }
+  });
+}
+function he(n, a) {
+  const e = z(a);
+  return n instanceof ReadableStream ? n.pipeThrough(e) : n.stream().pipeThrough(e);
+}
+async function Re(n) {
+  const a = await w(n), e = new Uint8Array(a);
+  if (e.length < 1)
     return "unknown";
-  const e = t[0];
-  return e === 1 ? "password" : e === 2 ? "keyfile" : "unknown";
+  const t = e[0];
+  return t === 1 ? "password" : t === 2 ? "keyfile" : t === 17 ? "password-stream" : t === 18 ? "keyfile-stream" : "unknown";
 }
-async function $(n) {
-  const a = await s(n), t = new Uint8Array(a);
-  if (t.length < 1)
+const Q = 34, Z = 18;
+async function _e(n) {
+  const a = await w(n), e = new Uint8Array(a);
+  if (e.length < 1)
     return !1;
-  const e = t[0];
-  return e === 1 && t.length >= 45 || e === 2 && t.length >= 29;
+  const t = e[0];
+  return t === 1 && e.length >= 45 || t === 2 && e.length >= 29 || t === 17 && e.length >= Q || t === 18 && e.length >= Z;
 }
-function q() {
-  const n = u(32);
+function Ae(n) {
+  return n === "password-stream" || n === "keyfile-stream";
+}
+function de() {
+  const n = S(32);
   return {
     version: 1,
     algorithm: "AES-256-GCM",
-    key: L(n.buffer),
+    key: Y(n.buffer),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function J(n) {
+function we(n) {
   try {
     const a = JSON.parse(n);
-    return Y(a) ? a : null;
+    return q(a) ? a : null;
   } catch {
     return null;
   }
 }
-function Y(n) {
+function q(n) {
   if (typeof n != "object" || n === null)
     return !1;
   const a = n;
   return a.version === 1 && a.algorithm === "AES-256-GCM" && typeof a.key == "string" && a.key.length > 0 && typeof a.createdAt == "string";
 }
-function z(n, a, t = "key") {
-  const e = {
+function Te(n, a, e = "key") {
+  const t = {
     version: 1,
     algorithm: "AES-256-GCM",
     key: n,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  }, i = JSON.stringify(e, null, 2), c = new Blob([i], { type: "application/json" }), r = URL.createObjectURL(c), y = document.createElement("a");
-  y.href = r, y.download = `${a}.${t}`, y.style.display = "none", document.body.appendChild(y), y.click(), document.body.removeChild(y), URL.revokeObjectURL(r);
+  }, r = JSON.stringify(t, null, 2), c = new Blob([r], { type: "application/json" }), i = URL.createObjectURL(c), s = document.createElement("a");
+  s.href = i, s.download = `${a}.${e}`, s.style.display = "none", document.body.appendChild(s), s.click(), document.body.removeChild(s), URL.revokeObjectURL(i);
 }
-async function X(n) {
-  const a = _(n), t = await crypto.subtle.digest("SHA-256", a), e = new Uint8Array(t);
-  return Array.from(e).map((i) => i.toString(16).padStart(2, "0")).join("");
+async function Ie(n) {
+  const a = O(n), e = await crypto.subtle.digest("SHA-256", a), t = new Uint8Array(e);
+  return Array.from(t).map((r) => r.toString(16).padStart(2, "0")).join("");
 }
-async function P(n, a) {
-  const { fileName: t, onProgress: e, ...i } = a;
+async function Se(n, a) {
+  const { fileName: e, onProgress: t, ...r } = a;
   try {
-    e == null || e({ phase: "downloading", progress: 0 });
+    t == null || t({ phase: "downloading", progress: 0 });
     const c = await fetch(n);
     if (!c.ok)
-      throw new p(
+      throw new o(
         "DOWNLOAD_FAILED",
         `Download failed: ${c.status} ${c.statusText}`
       );
-    const r = c.headers.get("content-length");
-    let y;
-    r && c.body ? y = await F(
+    const i = c.headers.get("content-length");
+    let s;
+    i && c.body ? s = await j(
       c.body,
-      parseInt(r, 10),
-      (E) => {
-        e == null || e({ phase: "downloading", progress: Math.round(E * 50) });
+      parseInt(i, 10),
+      (l) => {
+        t == null || t({ phase: "downloading", progress: Math.round(l * 50) });
       }
-    ) : (e == null || e({ phase: "downloading", progress: 25 }), y = await c.arrayBuffer()), e == null || e({ phase: "downloading", progress: 50 });
-    const f = await O(y, {
-      ...i,
-      onProgress: (E) => {
-        const d = 50 + Math.round(E.progress * 0.45);
-        e == null || e({
-          phase: E.phase === "complete" ? "complete" : E.phase,
-          progress: E.phase === "complete" ? 100 : d
+    ) : (t == null || t({ phase: "downloading", progress: 25 }), s = await c.arrayBuffer()), t == null || t({ phase: "downloading", progress: 50 });
+    const u = await V(s, {
+      ...r,
+      onProgress: (l) => {
+        const E = 50 + Math.round(l.progress * 0.45);
+        t == null || t({
+          phase: l.phase === "complete" ? "complete" : l.phase,
+          progress: l.phase === "complete" ? 100 : E
         });
       }
     });
-    H(f, t), e == null || e({ phase: "complete", progress: 100 });
+    $(u, e), t == null || t({ phase: "complete", progress: 100 });
   } catch (c) {
-    throw c instanceof p ? c : new p("DOWNLOAD_FAILED");
+    throw c instanceof o ? c : new o("DOWNLOAD_FAILED");
   }
 }
-async function F(n, a, t) {
-  const e = n.getReader(), i = [];
-  let c = 0, r = !1;
-  for (; !r; ) {
-    const E = await e.read();
-    if (r = E.done, E.value) {
-      i.push(E.value), c += E.value.length;
-      const d = c / a;
-      t(Math.min(d, 1));
+async function j(n, a, e) {
+  const t = n.getReader(), r = [];
+  let c = 0, i = !1;
+  for (; !i; ) {
+    const l = await t.read();
+    if (i = l.done, l.value) {
+      r.push(l.value), c += l.value.length;
+      const E = c / a;
+      e(Math.min(E, 1));
     }
   }
-  const y = new Uint8Array(c);
-  let f = 0;
-  for (const E of i)
-    y.set(E, f), f += E.length;
-  return y.buffer;
+  const s = new Uint8Array(c);
+  let u = 0;
+  for (const l of r)
+    s.set(l, u), u += l.length;
+  return s.buffer;
 }
-function H(n, a) {
-  const t = URL.createObjectURL(n), e = document.createElement("a");
-  e.href = t, e.download = a, e.style.display = "none", document.body.appendChild(e), e.click(), document.body.removeChild(e), URL.revokeObjectURL(t);
+function $(n, a) {
+  const e = URL.createObjectURL(n), t = document.createElement("a");
+  t.href = e, t.download = a, t.style.display = "none", document.body.appendChild(t), t.click(), document.body.removeChild(t), URL.revokeObjectURL(e);
 }
 export {
-  l as ALGORITHM,
-  B as AUTH_TAG_LENGTH,
-  p as CryptoError,
-  V as ENCRYPTION_MARKER_KEYFILE,
-  v as ENCRYPTION_MARKER_PASSWORD,
-  N as HASH_ALGORITHM,
-  G as IV_LENGTH,
-  M as KEYFILE_KEY_LENGTH,
-  C as KEY_LENGTH,
-  x as MIN_ENCRYPTED_SIZE_KEYFILE,
-  W as MIN_ENCRYPTED_SIZE_PASSWORD,
-  U as PBKDF2_ITERATIONS,
-  k as SALT_LENGTH,
-  X as computeKeyFileHash,
-  O as decryptFile,
-  P as downloadAndDecrypt,
-  z as downloadKeyFile,
-  Q as encryptFile,
-  q as generateKeyFile,
-  Z as generateRandomPassword,
-  g as getEncryptionType,
-  j as isCryptoError,
-  $ as isEncryptedFile,
-  J as parseKeyFile
+  _ as ALGORITHM,
+  oe as AUTH_TAG_LENGTH,
+  o as CryptoError,
+  ie as DEFAULT_CHUNK_SIZE,
+  re as ENCRYPTION_MARKER_KEYFILE,
+  ce as ENCRYPTION_MARKER_KEYFILE_STREAM,
+  ne as ENCRYPTION_MARKER_PASSWORD,
+  ae as ENCRYPTION_MARKER_PASSWORD_STREAM,
+  k as HASH_ALGORITHM,
+  P as IV_LENGTH,
+  te as KEYFILE_KEY_LENGTH,
+  X as KEY_LENGTH,
+  le as MIN_ENCRYPTED_SIZE_KEYFILE,
+  Ee as MIN_ENCRYPTED_SIZE_PASSWORD,
+  ee as PBKDF2_ITERATIONS,
+  J as SALT_LENGTH,
+  se as STREAM_FORMAT_VERSION,
+  Ie as computeKeyFileHash,
+  z as createDecryptStream,
+  x as createEncryptStream,
+  V as decryptFile,
+  he as decryptFileStream,
+  Se as downloadAndDecrypt,
+  Te as downloadKeyFile,
+  pe as encryptFile,
+  fe as encryptFileStream,
+  de as generateKeyFile,
+  ye as generateRandomPassword,
+  Re as getEncryptionType,
+  ue as isCryptoError,
+  _e as isEncryptedFile,
+  Ae as isStreamingEncryption,
+  we as parseKeyFile
 };
 //# sourceMappingURL=index.mjs.map