@fiduswriter/editor 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fiduswriter/editor",
-    "version": "0.1.8",
+    "version": "0.1.10",
     "description": "Fidus Writer browser editor",
     "repository": {
         "type": "git",
@@ -32,7 +32,7 @@
     },
     "dependencies": {
         "@fiduswriter/common": "^0.1.3",
-        "@fiduswriter/document": "^0.2.17",
+        "@fiduswriter/document": "^0.2.19",
         "bibliojson": "^4.0.0",
         "citeproc-plus": "^1.0.2",
         "cropperjs": "^1.6.2",
@@ -42,7 +42,7 @@
         "fast-deep-equal": "^3.1.3",
         "fast-xml-parser": "^4.5.0",
         "fix-utf8": "^2.0.1",
-        "fwtoolkit": "^0.1.4",
+        "fwtoolkit": "^0.1.9",
         "jszip": "^3.10.1",
         "mathml-to-latex": "^1.4.3",
         "mathml2omml": "^0.5.0",

package/src/collab/chat.js

@@ -1,5 +1,5 @@
 import {localizeDate, whenReady} from "fwtoolkit"
-import {E2EEEncryptor} from "../e2ee/encryptor.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
 import {messageTemplate} from "./templates.js"
 
 /*

package/src/collab/doc.js

@@ -3,11 +3,11 @@ import {Dialog, activateWait, deactivateWait, makeWorker} from "fwtoolkit"
 import {receiveTransaction, sendableSteps} from "prosemirror-collab"
 import {EditorState} from "prosemirror-state"
 import {Step} from "prosemirror-transform"
-import {E2EEEncryptor} from "../e2ee/encryptor.js"
-import {E2EEKeyManager} from "../e2ee/key-manager.js"
-import {enterPassphraseDialog} from "../e2ee/passphrase-dialog.js"
-import {PassphraseManager} from "../e2ee/passphrase-manager.js"
-import {enterPasswordDialog} from "../e2ee/password-dialog.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
+import {enterPassphraseDialog} from "fwtoolkit/e2ee/passphrase-dialog"
+import {PassphraseManager} from "fwtoolkit/e2ee/passphrase-manager"
+import {enterPasswordDialog} from "fwtoolkit/e2ee/password-dialog"
 import {
     getSelectionUpdate,
     removeCollaboratorSelection,
@@ -312,7 +312,7 @@ export class ModCollabDoc {
                     } else if (result?.action === "recover") {
                         // Recovery flow
                         const {recoverWithKeyDialog} = await import(
-                            "../e2ee/passphrase-dialog.js"
+                            "fwtoolkit/e2ee/passphrase-dialog"
                         )
                         const recoverResult = await new Promise(resolve => {
                             recoverWithKeyDialog(resolve)
@@ -325,7 +325,7 @@ export class ModCollabDoc {
                                         recoverResult.newPassphrase
                                     )
                                 const {showRecoveryKeyDialog} = await import(
-                                    "../e2ee/passphrase-dialog.js"
+                                    "fwtoolkit/e2ee/passphrase-dialog"
                                 )
                                 await new Promise(resolve => {
                                     showRecoveryKeyDialog(
@@ -685,7 +685,7 @@ export class ModCollabDoc {
         let decryptedImages = doc.images
         if (doc.images) {
             decryptedImages = {}
-            const {E2EEEncryptor} = await import("../e2ee/encryptor.js")
+            const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
             for (const [id, image] of Object.entries(doc.images)) {
                 decryptedImages[id] = image
                 if (typeof image.copyright === "string") {

package/src/dialogs/figure.js

@@ -3,7 +3,7 @@ import deepEqual from "fast-deep-equal"
 import {randomFigureId} from "@fiduswriter/document/schema/common/index"
 import {ContentMenu, Dialog, addAlert, dropdownSelect} from "fwtoolkit"
 import {ImageSelectionDialog} from "../images/selection_dialog/index.js"
-import {E2EEEncryptor} from "../e2ee/encryptor.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
 import {configureFigureTemplate} from "./templates.js"
 
 export class FigureDialog {

package/src/document_template/exporter.js

@@ -1,7 +1,7 @@
 import download from "downloadjs"
 
 import {createSlug} from "@fiduswriter/document/exporter/tools/file"
-import {ZipFileCreator} from "@fiduswriter/document/exporter/tools/zip"
+import {ZipFileCreator} from "fwtoolkit/file/zip"
 import {postJson} from "fwtoolkit"
 
 export class DocumentTemplateExporter {

package/src/document_template/index.js

@@ -7,11 +7,11 @@ import {
     shortFileTitle
 } from "fwtoolkit"
 import {SaveCopy} from "../exporter/native/index.js"
-import {E2EEKeyManager} from "../e2ee/key-manager.js"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
 import {
     createPasswordDialog,
     enterPasswordDialog
-} from "../e2ee/password-dialog.js"
+} from "fwtoolkit/e2ee/password-dialog"
 
 export {serializeHelp} from "./schema.js"
 

package/src/e2ee/snapshot-manager.js

@@ -68,7 +68,7 @@ export class E2EESnapshotManager {
         const bibliography = this.editor.docInfo.bibliography || {}
         const {title} = this.editor.getDoc()
 
-        const {E2EEEncryptor} = await import("./encryptor.js")
+        const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
         const encryptedContent = await E2EEEncryptor.encryptObject(
             content,
@@ -129,7 +129,7 @@ export class E2EESnapshotManager {
         const {title} = this.editor.getDoc()
 
         // Dynamically import to avoid circular dependencies
-        const {E2EEEncryptor} = await import("./encryptor.js")
+        const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
         // Encrypt all document data
         const encryptedContent = await E2EEEncryptor.encryptObject(
@@ -183,7 +183,7 @@ export class E2EESnapshotManager {
             this.clearKey()
             // Clear cached password and key from sessionStorage so the user
             // is prompted for the new password on next access.
-            const {E2EEKeyManager} = await import("./key-manager.js")
+            const {E2EEKeyManager} = await import("fwtoolkit/e2ee/key-manager")
             E2EEKeyManager.clearKeyFromSession(this.editor.docInfo.id)
             E2EEKeyManager.clearPasswordFromSession(this.editor.docInfo.id)
             // Notify the user that the password has changed.
@@ -213,7 +213,7 @@ export class E2EESnapshotManager {
             return
         }
 
-        const {E2EEEncryptor} = await import("./encryptor.js")
+        const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
         const encryptedContent = await E2EEEncryptor.encryptObject(
             content,
@@ -269,7 +269,7 @@ export class E2EESnapshotManager {
         // Extract the current title from the editor
         const {title} = this.editor.getDoc()
 
-        const {E2EEEncryptor} = await import("./encryptor.js")
+        const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
         // Encrypt with the new key
         const encryptedContent = await E2EEEncryptor.encryptObject(

package/src/exporter/native/copy.js

@@ -1,9 +1,144 @@
 import {SaveCopy as GenericSaveCopy} from "@fiduswriter/document/exporter/native"
-import {addProgress, gettext, shortFileTitle} from "fwtoolkit"
-import {E2EEEncryptor} from "../../e2ee/encryptor.js"
-import {E2EEKeyManager} from "../../e2ee/key-manager.js"
+import {addAlert, addProgress, gettext, postJson, shortFileTitle} from "fwtoolkit"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
 import {NativeImporter} from "@fiduswriter/document/importer/native"
 
+async function maybeDecryptImage(imageEntry, sourceKey) {
+    if (!sourceKey || !imageEntry.file) {
+        return
+    }
+    if (imageEntry.file_type !== "application/octet-stream") {
+        return
+    }
+    const fileBuffer = await imageEntry.file.arrayBuffer()
+    const bytes = new Uint8Array(fileBuffer)
+    let binary = ""
+    const chunkSize = 65536
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, i + chunkSize)
+        binary += String.fromCharCode.apply(null, chunk)
+    }
+    const base64 = btoa(binary)
+    const decrypted = await E2EEEncryptor.decryptBufferToBase64(base64, sourceKey)
+    const mime = imageEntry.original_file_type || "image/png"
+    const byteCharacters = atob(decrypted)
+    const byteNumbers = new Array(byteCharacters.length)
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i)
+    }
+    const byteArray = new Uint8Array(byteNumbers)
+    imageEntry.file = new Blob([byteArray], {type: mime})
+    imageEntry.file_type = mime
+}
+
+function createNativeImporterBackend(user, e2eeOptions) {
+    return {
+        createDoc: (template, importId, path, e2ee, files) => {
+            const jsonData = {
+                template: template.content,
+                export_templates: template.exportTemplates,
+                document_styles: template.documentStyles,
+                import_id: importId
+                    ? importId
+                    : template.content.attrs.import_id,
+                template_title: template.content.attrs.template,
+                path
+            }
+            if (e2ee?.enabled) {
+                jsonData.e2ee = true
+                if (e2ee.salt) {
+                    jsonData.e2ee_salt = e2ee.salt
+                }
+                if (e2ee.iterations) {
+                    jsonData.e2ee_iterations = e2ee.iterations
+                }
+            }
+            return postJson("/api/document/import/create/", jsonData, files)
+                .then(({json}) => ({
+                    id: json.id,
+                    path: json.path,
+                    e2ee: json.e2ee,
+                    template: json.template
+                }))
+                .catch(error => {
+                    addAlert("error", gettext("Could not create document"))
+                    throw error
+                })
+        },
+        saveImages: async (images, docId, e2ee) => {
+            const isE2EE = e2ee?.enabled
+            const endpoint = isE2EE
+                ? "/api/document/e2ee_image/"
+                : "/api/document/import/image/"
+            const imageTranslationTable = {}
+            await Promise.all(
+                Object.values(images.db).map(async imageEntry => {
+                    await maybeDecryptImage(imageEntry, e2ee?.sourceKey)
+                    const encryptedFile =
+                        e2ee?.enabled && e2ee.key
+                            ? await E2EEEncryptor.encryptImage(
+                                  imageEntry.file,
+                                  e2ee.key
+                              )
+                            : imageEntry.file
+                    const jsonData = {
+                        doc_id: docId,
+                        title: imageEntry.title,
+                        copyright: imageEntry.copyright,
+                        checksum: imageEntry.checksum
+                    }
+                    const files = {
+                        image: {
+                            file: encryptedFile,
+                            filename: imageEntry.image.split("/").pop()
+                        }
+                    }
+                    const {json} = await postJson(endpoint, jsonData, files)
+                    imageTranslationTable[imageEntry.id] = json.id
+                })
+            )
+            return imageTranslationTable
+        },
+        saveDocument: async (saveData, e2ee) => {
+            if (e2ee?.enabled && e2ee.key) {
+                saveData.content = await E2EEEncryptor.encryptObject(
+                    saveData.content,
+                    e2ee.key
+                )
+                saveData.comments = await E2EEEncryptor.encryptObject(
+                    saveData.comments || {},
+                    e2ee.key
+                )
+                saveData.bibliography = await E2EEEncryptor.encryptObject(
+                    saveData.bibliography,
+                    e2ee.key
+                )
+                saveData.title = await E2EEEncryptor.encrypt(
+                    saveData.title,
+                    e2ee.key
+                )
+            }
+            return postJson("/api/document/import/", saveData)
+                .then(({json}) => ({added: json.added, updated: json.updated}))
+                .catch(error => {
+                    addAlert(
+                        "error",
+                        `${gettext("Could not save ")} ${shortFileTitle(
+                            saveData.title,
+                            ""
+                        )}`
+                    )
+                    throw error
+                })
+        },
+        encryptImage: E2EEEncryptor.encryptImage.bind(E2EEEncryptor),
+        encryptObject: E2EEEncryptor.encryptObject.bind(E2EEEncryptor),
+        encrypt: E2EEEncryptor.encrypt.bind(E2EEEncryptor),
+        storeKeyInSession: E2EEKeyManager.storeKeyInSession.bind(E2EEKeyManager)
+    }
+}
+
 export class SaveCopy extends GenericSaveCopy {
     constructor(
         doc,
@@ -37,10 +172,12 @@ export class SaveCopy extends GenericSaveCopy {
                 imageDB,
                 httpIncludes,
                 options.user,
-                options.importId,
-                options.requestedPath,
-                null,
-                options.e2eeOptions
+                createNativeImporterBackend(options.user, options.e2eeOptions),
+                {
+                    importId: options.importId,
+                    requestedPath: options.requestedPath,
+                    e2eeOptions: options.e2eeOptions
+                }
             ).init()
 
         super(doc, bibDB, imageDB, newUser, {

package/src/footnotes/editor.js

@@ -11,7 +11,7 @@ import {EditorView} from "prosemirror-view"
 
 import {fnSchema} from "@fiduswriter/document/schema/footnotes"
 import {fnNodeToPmNode} from "@fiduswriter/document/schema/footnotes_convert"
-import {E2EEEncryptor} from "../e2ee/encryptor.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
 import {
     citationRenderPlugin,
     clipboardPlugin,

package/src/images/edit_dialog/edit_dialog/index.js

@@ -1,5 +1,5 @@
 import {CheckableList, ContentMenu, Dialog, addAlert} from "fwtoolkit"
-import {E2EEEncryptor} from "../../../e2ee/encryptor.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
 import {imageEditModel} from "./model.js"
 import {imageEditTemplate} from "./templates.js"
 export class ImageEditDialog {

package/src/index.js

@@ -20,18 +20,18 @@ import {EditorState, TextSelection} from "prosemirror-state"
 import {tableEditing} from "prosemirror-tables"
 import {EditorView} from "prosemirror-view"
 import {FeedbackTab} from "@fiduswriter/common"
-import {E2EEEncryptor} from "./e2ee/encryptor.js"
-import {E2EEKeyManager} from "./e2ee/key-manager.js"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
 import {
     enterPassphraseDialog,
     setupPassphraseDialog,
     showRecoveryKeyDialog
-} from "./e2ee/passphrase-dialog.js"
-import {PassphraseManager} from "./e2ee/passphrase-manager.js"
+} from "fwtoolkit/e2ee/passphrase-dialog"
+import {PassphraseManager} from "fwtoolkit/e2ee/passphrase-manager"
 import {
     changePasswordDialog,
     createPasswordDialog
-} from "./e2ee/password-dialog.js"
+} from "fwtoolkit/e2ee/password-dialog"
 import {E2EESnapshotManager} from "./e2ee/snapshot-manager.js"
 
 import {getSettings} from "@fiduswriter/document/schema/convert"
@@ -794,7 +794,7 @@ export class Editor {
                 } else if (result.action === "recover") {
                     // Recovery flow
                     const {recoverWithKeyDialog} = await import(
-                        "./e2ee/passphrase-dialog.js"
+                        "fwtoolkit/e2ee/passphrase-dialog"
                     )
                     const recoverResult = await new Promise(resolve => {
                         recoverWithKeyDialog(resolve)
@@ -807,7 +807,7 @@ export class Editor {
                                     recoverResult.newPassphrase
                                 )
                             const {showRecoveryKeyDialog} = await import(
-                                "./e2ee/passphrase-dialog.js"
+                                "fwtoolkit/e2ee/passphrase-dialog"
                             )
                             await new Promise(resolve => {
                                 showRecoveryKeyDialog(newRecoveryKey, resolve)

package/src/menus/headerbar/model.js

@@ -10,9 +10,9 @@ import {DocumentAccessRightsDialog} from "../../documents/access_rights/index.js
 import {SaveCopy, SaveRevision} from "../../exporter/native/index.js"
 import {ExportFidusFile} from "../../exporter/native/file.js"
 import {LanguageDialog, RevisionDialog} from "../../dialogs/index.js"
-import {E2EEKeyManager} from "../../e2ee/key-manager.js"
-import {PassphraseManager} from "../../e2ee/passphrase-manager.js"
-import {changePasswordDialog} from "../../e2ee/password-dialog.js"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
+import {PassphraseManager} from "fwtoolkit/e2ee/passphrase-manager"
+import {changePasswordDialog} from "fwtoolkit/e2ee/password-dialog"
 import {
     KeyBindingsDialog,
     SearchReplaceDialog,
@@ -435,7 +435,7 @@ export const headerbarModel = () => ({
                                                 editor.e2ee.encryptionIterations
                                             )
                                         const {E2EEEncryptor} = await import(
-                                            "../../e2ee/encryptor.js"
+                                            "fwtoolkit/e2ee/encryptor"
                                         )
                                         const testValue = "test"
                                         const encryptedTest =

package/src/e2ee/encryptor.js

@@ -1,228 +0,0 @@
-/**
- * E2EE Encryptor - Handles encryption and decryption of document content
- * for end-to-end encrypted documents.
- *
- * Uses AES-GCM (256-bit) for all encryption operations. Each encryption
- * operation generates a random 12-byte IV (initialization vector) to
- * ensure that encrypting the same plaintext twice produces different
- * ciphertext.
- *
- * Encrypted data format (Appendix A of the E2EE plan):
- *   [IV (12 bytes)][Ciphertext (variable length)][Auth Tag (16 bytes, implicit in AES-GCM)]
- *
- * When stored as a string (e.g., in JSON fields), the entire structure
- * is Base64-encoded.
- */
-export class E2EEEncryptor {
-    /**
-     * Encrypt a string with AES-GCM.
-     *
-     * @param {string} plaintext - The plaintext string to encrypt
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} Base64-encoded string (iv + ciphertext + auth tag)
-     */
-    static async encrypt(plaintext, key) {
-        const iv = crypto.getRandomValues(new Uint8Array(12))
-        const encoded = new TextEncoder().encode(plaintext)
-        const ciphertext = await crypto.subtle.encrypt(
-            {name: "AES-GCM", iv: iv},
-            key,
-            encoded
-        )
-        // Prepend IV to ciphertext for storage
-        const combined = new Uint8Array(iv.length + ciphertext.byteLength)
-        combined.set(iv, 0)
-        combined.set(new Uint8Array(ciphertext), iv.length)
-        return E2EEEncryptor._uint8ArrayToBase64(combined)
-    }
-
-    /**
-     * Decrypt a Base64-encoded AES-GCM ciphertext.
-     *
-     * @param {string} ciphertextBase64 - Base64-encoded (iv + ciphertext + auth tag)
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} The decrypted plaintext string
-     */
-    static async decrypt(ciphertextBase64, key) {
-        const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
-        const iv = combined.slice(0, 12)
-        const ciphertext = combined.slice(12)
-        const decrypted = await crypto.subtle.decrypt(
-            {name: "AES-GCM", iv: iv},
-            key,
-            ciphertext
-        )
-        return new TextDecoder().decode(decrypted)
-    }
-
-    /**
-     * Encrypt a JSON-serializable object.
-     *
-     * Serializes the object to JSON, then encrypts the JSON string.
-     *
-     * @param {Object} obj - A JSON-serializable object
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data
-     */
-    static encryptObject(obj, key) {
-        return E2EEEncryptor.encrypt(JSON.stringify(obj), key)
-    }
-
-    /**
-     * Decrypt to a JSON-serializable object.
-     *
-     * Decrypts the Base64-encoded ciphertext, then parses the result as JSON.
-     *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Object>} The decrypted and parsed object
-     */
-    static async decryptObject(ciphertextBase64, key) {
-        const plaintext = await E2EEEncryptor.decrypt(ciphertextBase64, key)
-        return JSON.parse(plaintext)
-    }
-
-    /**
-     * Encrypt an ArrayBuffer (for images and other binary data).
-     *
-     * @param {ArrayBuffer} buffer - The binary data to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data (iv + ciphertext)
-     */
-    static async encryptBuffer(buffer, key) {
-        const iv = crypto.getRandomValues(new Uint8Array(12))
-        const ciphertext = await crypto.subtle.encrypt(
-            {name: "AES-GCM", iv: iv},
-            key,
-            buffer
-        )
-        // Prepend IV to ciphertext
-        const combined = new Uint8Array(iv.length + ciphertext.byteLength)
-        combined.set(iv, 0)
-        combined.set(new Uint8Array(ciphertext), iv.length)
-        return E2EEEncryptor._uint8ArrayToBase64(combined)
-    }
-
-    /**
-     * Decrypt to an ArrayBuffer.
-     *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted binary data
-     */
-    static decryptBuffer(ciphertextBase64, key) {
-        const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
-        const iv = combined.slice(0, 12)
-        const ciphertext = combined.slice(12)
-        return crypto.subtle.decrypt({name: "AES-GCM", iv: iv}, key, ciphertext)
-    }
-
-    /**
-     * Encrypt an image File/Blob for upload.
-     *
-     * Reads the file as an ArrayBuffer, encrypts it, and returns
-     * a Blob with application/octet-stream type (since the encrypted
-     * data is opaque binary).
-     *
-     * @param {File|Blob} file - The image file to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Blob>} An encrypted Blob with type application/octet-stream
-     */
-    static async encryptImage(file, key) {
-        const buffer = await file.arrayBuffer()
-        const iv = crypto.getRandomValues(new Uint8Array(12))
-        const ciphertext = await crypto.subtle.encrypt(
-            {name: "AES-GCM", iv: iv},
-            key,
-            buffer
-        )
-        // Prepend IV to ciphertext
-        const combined = new Uint8Array(iv.length + ciphertext.byteLength)
-        combined.set(iv, 0)
-        combined.set(new Uint8Array(ciphertext), iv.length)
-        return new Blob([combined], {type: "application/octet-stream"})
-    }
-
-    /**
-     * Decrypt an encrypted image back to an ArrayBuffer.
-     *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted image data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted image data
-     */
-    static decryptImage(ciphertextBase64, key) {
-        return E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
-    }
-
-    /**
-     * Decrypt a Base64-encoded ciphertext and return as a Base64 string.
-     *
-     * Useful for decrypting encrypted images that need to be stored
-     * as Base64 data URLs or re-exported.
-     *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded decrypted data
-     */
-    static async decryptBufferToBase64(ciphertextBase64, key) {
-        const buffer = await E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
-        const bytes = new Uint8Array(buffer)
-        let binary = ""
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i])
-        }
-        return btoa(binary)
-    }
-
-    /**
-     * Decrypt an encrypted image and return a blob URL for display.
-     *
-     * Fetches the encrypted image file from the given URL, decrypts it,
-     * and creates a temporary object URL that can be used as an img src.
-     *
-     * @param {string} imageUrl - The URL of the encrypted image file
-     * @param {CryptoKey} key - An AES-GCM key
-     * @param {string} mimeType - The MIME type of the decrypted image
-     * @returns {Promise<string>} A blob URL for the decrypted image
-     */
-    static async decryptImageToUrl(imageUrl, key, mimeType = "image/png") {
-        const response = await fetch(imageUrl)
-        const arrayBuffer = await response.arrayBuffer()
-        const bytes = new Uint8Array(arrayBuffer)
-        let binary = ""
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i])
-        }
-        const base64 = btoa(binary)
-        const decrypted = await E2EEEncryptor.decryptBuffer(base64, key)
-        const blob = new Blob([decrypted], {type: mimeType})
-        return URL.createObjectURL(blob)
-    }
-
-    // --- Private helper methods ---
-
-    /**
-     * Convert a Uint8Array to a Base64-encoded string.
-     * @private
-     */
-    static _uint8ArrayToBase64(bytes) {
-        let binary = ""
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i])
-        }
-        return btoa(binary)
-    }
-
-    /**
-     * Convert a Base64-encoded string to a Uint8Array.
-     * @private
-     */
-    static _base64ToUint8Array(base64) {
-        const binary = atob(base64)
-        const bytes = new Uint8Array(binary.length)
-        for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i)
-        }
-        return bytes
-    }
-}