@secrecy/lib 1.86.2-fix-md5.1 → 1.86.3

package/dist/lib/crypto/data.js

@@ -1,5 +1,6 @@
 import { setup, sodium } from '../sodium.js';
 import SparkMD5 from 'spark-md5';
+import { chunks } from '../utils/array.js';
 function assert(c, message) {
     if (!c) {
         throw new Error(message);
@@ -8,19 +9,7 @@ function assert(c, message) {
 export function secretStreamKeygen() {
     return sodium.crypto_secretstream_xchacha20poly1305_keygen();
 }
-function assertKey(key) {
-    assert(key.byteLength === sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES, `key must be KEYBYTES (${sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES}) long`);
-}
-// The wrappers return the secretstream state as a raw address in the wasm
-// heap and never release it: wipe it (it holds the stream key) and free it.
-function wipeState(state) {
-    const lib = sodium.libsodium;
-    const size = lib._crypto_secretstream_xchacha20poly1305_statebytes();
-    lib.HEAPU8.fill(0, state, state + size);
-    lib._free(state);
-}
 function encrypt(key) {
-    assertKey(key);
     let destroyed = false;
     const { state, header } = sodium.crypto_secretstream_xchacha20poly1305_init_push(key);
     const encrypt = (tag, plaintext) => {
@@ -30,7 +19,6 @@ function encrypt(key) {
     function destroy() {
         assert(!destroyed, 'state already destroyed');
         destroyed = true;
-        wipeState(state);
     }
     return {
         encrypt,
@@ -39,9 +27,9 @@ function encrypt(key) {
     };
 }
 function decrypt(header, key) {
-    assert(header.byteLength ===
-        sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES, `header must be HEADERBYTES (${sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES}) long`);
-    assertKey(key);
+    assert(header.byteLength >=
+        sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES, `header must be at least HEADERBYTES (${sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES}) long`);
+    assert(key.byteLength >= sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES, `key must be at least KEYBYTES (${sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES}) long`);
     let destroyed = false;
     const state = sodium.crypto_secretstream_xchacha20poly1305_init_pull(header, key);
     const decrypt = (ciphertext) => {
@@ -51,7 +39,6 @@ function decrypt(header, key) {
     function destroy() {
         assert(!destroyed, 'state already destroyed');
         destroyed = true;
-        wipeState(state);
     }
     return {
         decrypt,
@@ -59,146 +46,104 @@ function decrypt(header, key) {
     };
 }
 export const CHUNK_SIZE = 8192;
-/**
- * Encrypt `data` as a secretstream: the header followed by one authenticated
- * chunk per CHUNK_SIZE bytes of plaintext. The last chunk (an empty one for
- * empty data) is always tagged `TAG_FINAL` so that truncation is detected.
- */
 export async function encryptSecretStream(key, data, progress, signal) {
     await setup();
     const { encrypt: crypt, destroy, header } = encrypt(key);
-    try {
-        const chunkCount = Math.max(1, Math.ceil(data.byteLength / CHUNK_SIZE));
-        const max = header.byteLength +
-            data.byteLength +
-            chunkCount * sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
-        void progress?.({
-            percent: 0,
-            total: max,
-            current: 0,
-        });
-        const final = new Uint8Array(max);
-        const sparkEncrypted = new SparkMD5.ArrayBuffer();
-        final.set(header);
-        sparkEncrypted.append(header.buffer);
-        let total = header.byteLength;
-        void progress?.({
-            percent: total / max,
-            total: max,
-            current: total,
-        });
-        let lastPercent = total / max;
-        for (let i = 0; i < chunkCount; i++) {
-            if (signal?.aborted === true) {
-                throw new Error(`Encrypt aborted`);
-            }
-            const chunk = data.subarray(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
-            const tag = i === chunkCount - 1
-                ? sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL
-                : sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
-            const encrypted = crypt(tag, chunk);
-            sparkEncrypted.append(encrypted.buffer);
-            final.set(encrypted, total);
-            total += encrypted.byteLength;
-            const percent = total / max;
-            if (percent > lastPercent + 0.01) {
-                void progress?.({
-                    percent,
-                    total: max,
-                    current: total,
-                });
-                lastPercent = percent;
-            }
+    const encryptedChunk = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+    const max = Math.ceil(data.byteLength / CHUNK_SIZE) * encryptedChunk + header.byteLength;
+    void progress?.({
+        percent: 0,
+        total: max,
+        current: 0,
+    });
+    const final = new Uint8Array(max);
+    const sparkEncrypted = new SparkMD5.ArrayBuffer();
+    const spark = new SparkMD5.ArrayBuffer();
+    final.set(header);
+    sparkEncrypted.append(header.buffer);
+    let total = header.byteLength;
+    void progress?.({
+        percent: total / max,
+        total: max,
+        current: total,
+    });
+    let lastPercent = total / max;
+    for (const chunk of chunks(data, CHUNK_SIZE)) {
+        if (signal?.aborted === true) {
+            throw new Error(`Encrypt aborted`);
+        }
+        spark.append(chunk.buffer);
+        const tag = chunk.length < CHUNK_SIZE
+            ? sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL
+            : sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
+        const encrypted = crypt(tag, chunk);
+        sparkEncrypted.append(encrypted.buffer);
+        final.set(encrypted, total);
+        total += encrypted.byteLength;
+        const percent = total / max;
+        if (percent > lastPercent + 0.01) {
+            void progress?.({
+                percent,
+                total: max,
+                current: total,
+            });
+            lastPercent = percent;
         }
-        void progress?.({
-            percent: 1,
-            total,
-            current: total,
-        });
-        return {
-            data: final,
-            md5Encrypted: sparkEncrypted.end(),
-        };
-    }
-    finally {
-        destroy();
     }
+    destroy();
+    void progress?.({
+        percent: 1,
+        total,
+        current: total,
+    });
+    return {
+        data: final.slice(0, total),
+        md5Encrypted: sparkEncrypted.end(),
+        md5: spark.end(),
+    };
 }
-/**
- * Decrypt a secretstream produced by `encryptSecretStream`. Throws if any
- * chunk fails authentication, if data follows the `TAG_FINAL` chunk, or if the
- * stream ends without it (truncation).
- */
 export async function decryptSecretStream(key, data, progress, signal) {
     await setup();
-    const headerBytes = sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES;
-    const chunkSize = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
-    // A valid stream always holds at least one (possibly empty) chunk.
-    if (data.byteLength <
-        headerBytes + sodium.crypto_secretstream_xchacha20poly1305_ABYTES) {
-        throw new Error('Unable to decrypt the data: the data is too short!');
-    }
-    const header = data.slice(0, headerBytes);
-    const body = data.subarray(headerBytes);
-    const chunkCount = Math.ceil(body.byteLength / chunkSize);
-    const max = body.byteLength -
-        chunkCount * sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+    const header = data.slice(0, sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+    data = data.slice(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
     const { decrypt: decryptFn, destroy } = decrypt(header, key);
-    try {
-        void progress?.({
-            percent: 0,
-            total: max,
-            current: 0,
-        });
-        const final = new Uint8Array(max);
-        let total = 0;
-        let finalTagSeen = false;
-        let lastPercent = total / max;
-        for (let i = 0; i < chunkCount; i++) {
-            if (signal?.aborted === true) {
-                throw new Error(`Decrypt aborted`);
-            }
-            const chunk = body.subarray(i * chunkSize, (i + 1) * chunkSize);
-            if (finalTagSeen) {
-                throw new Error('Unable to decrypt the data: unexpected data after the final chunk!');
-            }
-            const messageTag = decryptFn(chunk);
-            if (typeof messageTag === 'boolean') {
-                throw new Error('Unable to decrypt the data!');
-            }
-            if (messageTag.tag ===
-                sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL) {
-                finalTagSeen = true;
-            }
-            else if (messageTag.tag !==
-                sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE) {
-                throw new Error('Unable to decrypt the data: unexpected chunk tag!');
-            }
-            final.set(messageTag.message, total);
-            total += messageTag.message.byteLength;
-            const percent = total / max;
-            if (percent > lastPercent + 0.01) {
-                void progress?.({
-                    percent,
-                    total: max,
-                    current: total,
-                });
-                lastPercent = percent;
-            }
+    const chunkSize = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+    const max = Math.ceil(data.byteLength / chunkSize) * CHUNK_SIZE;
+    void progress?.({
+        percent: 0,
+        total: max,
+        current: 0,
+    });
+    const final = new Uint8Array(max);
+    let total = 0;
+    let lastPercent = total / max;
+    for (const chunk of chunks(data, chunkSize)) {
+        if (signal?.aborted === true) {
+            throw new Error(`Decrypt aborted`);
         }
-        if (!finalTagSeen) {
-            throw new Error('Unable to decrypt the data: the data is truncated!');
+        const messageTag = decryptFn(chunk);
+        if (typeof messageTag === 'boolean') {
+            throw new Error('Unable to decrypt the data!');
+        }
+        final.set(messageTag.message, total);
+        total += messageTag.message.byteLength;
+        const percent = total / max;
+        if (percent > lastPercent + 0.01) {
+            void progress?.({
+                percent,
+                total: max,
+                current: total,
+            });
+            lastPercent = percent;
         }
-        void progress?.({
-            percent: 1,
-            total,
-            current: total,
-        });
-        return final;
-    }
-    finally {
-        destroy();
     }
+    destroy();
+    void progress?.({
+        percent: 1,
+        total,
+        current: total,
+    });
+    return final.slice(0, total);
 }
 // async function mainSecretStream(random: Uint8Array): Promise<vo id> {
 //   const key = secretstreamKeygen();

package/dist/lib/crypto/domain.js

@@ -11,11 +11,12 @@ import { concatenate } from '../utils/array.js';
  */
 export async function encryptDataAndKey({ data, currentIdentity, keyPairs, progress, signal, }) {
     const dataKey = secretStreamKeygen();
-    const { data: encryptedData, md5Encrypted } = await encrypt(dataKey, data, progress, signal);
+    const { data: encryptedData, md5: md5Data, md5Encrypted, } = await encrypt(dataKey, data, progress, signal);
     if (!currentIdentity || !keyPairs) {
         return {
             encryptedData,
             dataKey,
+            md5Data,
             md5Encrypted,
         };
     }
@@ -28,6 +29,7 @@ export async function encryptDataAndKey({ data, currentIdentity, keyPairs, progr
         encryptedDataKey: encDataKey,
         encryptedData,
         dataKey,
+        md5Data,
         md5Encrypted,
     };
 }

package/dist/lib/crypto/helpers.js

@@ -1,6 +1,5 @@
-import { decryptSecretBox, encryptCryptoBox, encryptSecretBox } from '.';
+import { encryptCryptoBox } from '.';
 import { sodium } from '../sodium';
-import { concatenate } from '../utils/array.js';
 import { encryptSecretStream, secretStreamKeygen } from './data';
 export function generatePassword() {
     return sodium.randombytes_buf(16, 'hex');
@@ -8,27 +7,6 @@ export function generatePassword() {
 export function derivePassword(password, salt) {
     return sodium.crypto_pwhash(sodium.crypto_secretbox_KEYBYTES, password, salt, sodium.crypto_pwhash_OPSLIMIT_INTERACTIVE, sodium.crypto_pwhash_MEMLIMIT_INTERACTIVE, sodium.crypto_pwhash_ALG_ARGON2ID13, 'hex');
 }
-const PASSWORD_KEY_VERSION = 1;
-/**
- * Wrap a data key under a password, with a random salt:
- * `version (1 byte) || salt || nonce || secretbox(key)`.
- */
-export function encryptKeyWithPassword(key, password) {
-    const salt = sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES);
-    return concatenate(new Uint8Array([PASSWORD_KEY_VERSION]), salt, encryptSecretBox(key, derivePassword(password, salt)));
-}
-/** Unwrap a data key produced by `encryptKeyWithPassword`. */
-export function decryptKeyWithPassword(wrapped, password) {
-    const boxBytes = sodium.crypto_secretbox_NONCEBYTES +
-        sodium.crypto_secretbox_MACBYTES +
-        sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES;
-    if (wrapped.byteLength === 1 + sodium.crypto_pwhash_SALTBYTES + boxBytes &&
-        wrapped[0] === PASSWORD_KEY_VERSION) {
-        const salt = wrapped.slice(1, 1 + sodium.crypto_pwhash_SALTBYTES);
-        return decryptSecretBox(wrapped.slice(1 + sodium.crypto_pwhash_SALTBYTES), derivePassword(password, salt));
-    }
-    throw new Error('Unsupported password protected key format');
-}
 export async function encryptName(name, nameKey) {
     const { data } = await encryptSecretStream(sodium.from_hex(nameKey), sodium.from_string(name));
     return sodium.to_hex(data);

package/dist/lib/crypto/index.js

@@ -1,5 +1,12 @@
 import { concatenate } from '../utils/array.js';
 import { sodium } from '../sodium.js';
+function dataTooShortError() {
+    return {
+        name: 'ClientError',
+        code: 'DATA_TOO_SHORT',
+        message: 'Encrypted payload is shorter than nonce + MAC',
+    };
+}
 export function encryptCryptoBox(data, publicKeyBob, privateKeyAlice) {
     const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
     const crypt = sodium.crypto_box_easy(data, nonce, sodium.from_hex(publicKeyBob), sodium.from_hex(privateKeyAlice));
@@ -10,7 +17,7 @@ export function generateCryptoBoxKeyPair() {
 }
 export function decryptCryptoBox(data, publicKeyAlice, privateKeyBob) {
     if (data.length < sodium.crypto_box_NONCEBYTES + sodium.crypto_box_MACBYTES) {
-        throw new Error('data too short');
+        throw dataTooShortError();
     }
     const nonce = data.slice(0, sodium.crypto_box_NONCEBYTES);
     const cipher = data.slice(sodium.crypto_box_NONCEBYTES);
@@ -27,7 +34,7 @@ export function encryptSecretBox(data, key) {
 export function decryptSecretBox(data, key) {
     if (data.length <
         sodium.crypto_secretbox_NONCEBYTES + sodium.crypto_secretbox_MACBYTES) {
-        throw new Error('data too short');
+        throw dataTooShortError();
     }
     const nonce = data.slice(0, sodium.crypto_secretbox_NONCEBYTES);
     const cipher = data.slice(sodium.crypto_secretbox_NONCEBYTES);

package/dist/lib/error/client.js

@@ -1,5 +1,11 @@
 import { z } from 'zod';
-export const clientErrorCodeKey = z.enum(['NOT_FOUND']);
+export const clientErrorCodeKey = z.enum([
+    'NOT_FOUND',
+    'DATA_TOO_SHORT',
+    'POPUP_BLOCKED',
+    'POPUP_CLOSED',
+    'SERVER_ENVIRONMENT',
+]);
 export const clientError = z.object({
     name: z.literal('ClientError'),
     code: clientErrorCodeKey,

package/dist/lib/react/index.js

@@ -0,0 +1,69 @@
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
+import { initSecrecy, login as secrecyLogin } from '../client/helpers.js';
+const SecrecyContext = createContext(null);
+export function SecrecyProvider(props) {
+    const { appId, session, redirect, secrecyUrls, children } = props;
+    const [client, setClient] = useState(null);
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const secrecyUrlsKey = JSON.stringify(secrecyUrls ?? null);
+    useEffect(() => {
+        let cancelled = false;
+        setStatus('loading');
+        initSecrecy({ appId, session, redirect, secrecyUrls })
+            .then((result) => {
+            if (cancelled)
+                return;
+            setClient(result);
+            setStatus(result !== null ? 'authenticated' : 'idle');
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setError(err);
+            setStatus('error');
+        });
+        return () => {
+            cancelled = true;
+        };
+        // secrecyUrls is tracked through secrecyUrlsKey, a stable primitive.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [appId, session, redirect, secrecyUrlsKey]);
+    const login = useCallback(async () => {
+        setStatus('loading');
+        setError(null);
+        try {
+            const result = await secrecyLogin({
+                appId,
+                session,
+                secrecyUrls,
+                forceLogin: true,
+            });
+            setClient(result);
+            setStatus('authenticated');
+        }
+        catch (err) {
+            setError(err);
+            setStatus('error');
+        }
+        // secrecyUrls is tracked through secrecyUrlsKey, a stable primitive.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [appId, session, secrecyUrlsKey]);
+    const logout = useCallback(async () => {
+        if (client === null) {
+            return;
+        }
+        await client.logout();
+        setClient(null);
+        setStatus('idle');
+    }, [client]);
+    const value = useMemo(() => ({ client, status, error, login, logout }), [client, status, error, login, logout]);
+    return createElement(SecrecyContext.Provider, { value }, children);
+}
+export function useSecrecy() {
+    const ctx = useContext(SecrecyContext);
+    if (ctx === null) {
+        throw new Error('useSecrecy() must be used within a <SecrecyProvider>');
+    }
+    return ctx;
+}

package/dist/lib/transformer.js

@@ -10,9 +10,10 @@ superjson.registerCustom({
     serialize: (v) => v.toJSON(),
     deserialize: (v) => Temporal.PlainDateTime.from(v),
 }, 'Temporal.PlainDateTime');
+const hasBuffer = typeof globalThis.Buffer !== 'undefined';
 superjson.registerCustom({
-    isApplicable: (v) => v instanceof Buffer,
+    isApplicable: (v) => hasBuffer && v instanceof globalThis.Buffer,
     serialize: (v) => [...v],
-    deserialize: (v) => Buffer.from(v),
+    deserialize: (v) => globalThis.Buffer.from(v),
 }, 'buffer');
 export const transformer = superjson;

package/dist/lib/utils/popup-tools.js

@@ -10,7 +10,6 @@ const defaultOptions = {
     scrollbars: 'no',
     centered: true,
 };
-let popupCount = 1;
 /**
  * Return options converted to a string
  *
@@ -23,12 +22,11 @@ function optionsToString(options) {
         .join(',');
 }
 /**
- * Get a unique name on each call
+ * Get an unpredictable, unique name on each call
  * @return {String}
  */
 function defaultPopupName() {
-    popupCount += 1;
-    return `Popup ${popupCount}`;
+    return `secrecy-${crypto.randomUUID()}`;
 }
 /**
  * Convert "centered: true" key into concrete left and top arguments
@@ -100,30 +98,26 @@ function popupExecute(execute, url, name, options, callback) {
             //
         };
     const optionsString = optionsToString(popupOptions);
-    // Only the page we opened may answer: the popup name is predictable, so
-    // without these checks any window could inject a response (e.g. an
-    // attacker's session and keys on login).
-    const expectedOrigin = new URL(url, window.location.href).origin;
     const win = execute(url, popupName, optionsString);
+    const expectedOrigin = new URL(url, window.location.href).origin;
     let isMessageSent = false;
     let interval;
     function popupCallbackOnce(err, data) {
         if (!isMessageSent) {
             isMessageSent = true;
-            window.removeEventListener('message', onMessage);
-            clearInterval(interval);
             popupCallback(err, data);
         }
     }
     function onMessage(message) {
-        if (win === null ||
-            message.source !== win ||
-            message.origin !== expectedOrigin) {
+        if (message === undefined || message.origin !== expectedOrigin) {
+            console.error('Invalid message origin', message?.origin, expectedOrigin);
             return;
         }
         const data = message.data;
-        if (data !== undefined && data !== null && data.id === popupName) {
+        if (data !== undefined && data.id === popupName) {
             popupCallbackOnce(undefined, data.data);
+            window.removeEventListener('message', onMessage);
+            clearInterval(interval);
         }
     }
     window.addEventListener('message', onMessage, false);
@@ -132,13 +126,21 @@ function popupExecute(execute, url, name, options, callback) {
             if (win === null || win.closed) {
                 setTimeout(function delayWindowClosing() {
                     clearInterval(interval);
-                    popupCallbackOnce(new Error('Popup closed'));
+                    popupCallbackOnce({
+                        name: 'ClientError',
+                        code: 'POPUP_CLOSED',
+                        message: 'The popup was closed before completing',
+                    });
                 }, 500);
             }
         }, 100);
     }
     else {
-        popupCallbackOnce(new Error('Popup blocked'));
+        popupCallbackOnce({
+            name: 'ClientError',
+            code: 'POPUP_BLOCKED',
+            message: 'The popup was blocked by the browser',
+        });
     }
     return win;
 }
@@ -179,14 +181,8 @@ export function popupWithPost(url, postData, name, options, callback) {
 }
 /**
  * Return html that when executed, will trigger the popup to callback with a response
- *
- * @param  {Object}
- * @param  {String} targetOrigin origin of the opener allowed to receive `data`
- * @return {String}
  */
 export function popupResponse(id, data, targetOrigin) {
-    // Escape "<" so the payload cannot close the script tag.
-    const jsonData = JSON.stringify({ id, data }).replaceAll('<', '\\u003c');
-    const origin = JSON.stringify(targetOrigin).replaceAll('<', '\\u003c');
-    return `<script>window.opener.postMessage(${jsonData}, ${origin});setTimeout(function() { window.close(); }, 50);</script>`;
+    const jsonData = JSON.stringify({ id, data });
+    return `<script>window.opener.postMessage(${jsonData}, ${JSON.stringify(targetOrigin)});setTimeout(function() { window.close(); }, 50);</script>`;
 }

package/dist/lib/versioning.js

@@ -1 +1 @@
-export const SECRECY_LIB_VERSION = '1.0.0';
+export const SECRECY_LIB_VERSION = '1.86.3';

package/dist/lib/worker/md5.js

@@ -1,4 +1,5 @@
 import SparkMD5 from 'spark-md5';
+import { workerMd5Script } from './workerCodes.js';
 function* chunks(arr, n) {
     for (let i = 0; i < arr.length; i += n) {
         yield arr.slice(i, i + n);
@@ -7,9 +8,8 @@ function* chunks(arr, n) {
 const CHUNK_SIZE = 8192;
 export const md5 = process.env.NODE_ENV !== 'test'
     ? async (data) => {
-        const { workerMd5Script } = await import('./generated/md5.js');
-        const worker = new Worker(URL.createObjectURL(new Blob([workerMd5Script], { type: 'text/javascript' })));
         return await new Promise((resolve, reject) => {
+            const worker = new Worker(URL.createObjectURL(new Blob([workerMd5Script], { type: 'text/javascript' })));
             worker.addEventListener('error', reject);
             worker.addEventListener('messageerror', reject);
             worker.addEventListener('message', ({ data }) => {

package/dist/lib/worker/sodium.js

@@ -1,18 +1,26 @@
 import { decryptSecretStream, encryptSecretStream, } from '../crypto/data.js';
-// Loaded lazily so the bundled libsodium only ships when a worker is needed.
-const createSodiumWorker = async () => {
-    const { workerSodiumScript } = await import('./generated/sodium.js');
-    return new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
-};
+import { workerSodiumScript } from './workerCodes.js';
+// const ensureNonDetachedUniqueBuffers = (
+//   values: Transferable[]
+// ): Set<Transferable> =>
+//   new Set(
+//     values.filter(v => {
+//       if (v instanceof ArrayBuffer) {
+//         return v.byteLength === 0;
+//       } else {
+//         return true;
+//       }
+//     })
+//   );
 export const encrypt = process.env.NODE_ENV !== 'test'
     ? async (key, dataToEncrypt, progress, signal) => {
-        const worker = await createSodiumWorker();
         return await new Promise((resolve, reject) => {
             void progress?.({
                 current: 0,
                 percent: 0,
                 total: dataToEncrypt.byteLength,
             });
+            const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
             worker.addEventListener('error', reject);
             worker.addEventListener('messageerror', reject);
             worker.addEventListener('message', ({ data }) => {
@@ -38,11 +46,6 @@ export const encrypt = process.env.NODE_ENV !== 'test'
                         void progress?.(data.data);
                         break;
                     }
-                    case 'error': {
-                        worker.terminate();
-                        reject(new Error(data.data));
-                        break;
-                    }
                     case 'encrypt-result': {
                         worker.terminate();
                         resolve(data.data);
@@ -56,13 +59,13 @@ export const encrypt = process.env.NODE_ENV !== 'test'
     };
 export const decrypt = process.env.NODE_ENV !== 'test'
     ? async (key, dataToDecrypt, progress, signal) => {
-        const worker = await createSodiumWorker();
         return await new Promise((resolve, reject) => {
             void progress?.({
                 current: 0,
                 percent: 0,
                 total: dataToDecrypt.byteLength,
             });
+            const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
             worker.addEventListener('error', reject);
             worker.addEventListener('messageerror', reject);
             worker.addEventListener('message', ({ data }) => {
@@ -88,11 +91,6 @@ export const decrypt = process.env.NODE_ENV !== 'test'
                         void progress?.(data.data);
                         break;
                     }
-                    case 'error': {
-                        worker.terminate();
-                        reject(new Error(data.data));
-                        break;
-                    }
                     case 'decrypt-result': {
                         worker.terminate();
                         resolve(data.data);