A fully open source & end-to-end encrypted note taking alternative to Evernote.
TypeScript asp-net-coredotnet-coreelectronfosshacktoberfestnote-managmentnote-takingnote-taking-appnotebooknotesnotes-appopen-sourceopensourceprivacyproductivityreactreact-nativereactjsself-hosted
core: add tests covering password reset & other crypto apis
Abdullah Attaa3d672362fb4
diff --git a/packages/core/__mocks__/node-storage.mock.ts b/packages/core/__mocks__/node-storage.mock.tsindex 0677e125d..f771faa70 100644--- a/packages/core/__mocks__/node-storage.mock.ts+++ b/packages/core/__mocks__/node-storage.mock.ts@@ -27,7 +27,7 @@ import { IStorage } from "../src/interfaces.js";import { randomBytes } from "crypto";export class NodeStorageInterface implements IStorage {- storage = {};+ storage: Record<string, unknown> = {};crypto = new NNCrypto();async removeMulti(keys: string[]): Promise<void> {@@ -49,7 +49,7 @@ export class NodeStorageInterface implements IStorage {async readMulti<T>(keys: string[]): Promise<[string, T][]> {const result: [string, T][] = [];keys.forEach((key) => {- result.push([key, this.storage[key]]);+ result.push([key, this.storage[key] as T]);});return result;}@@ -58,7 +58,7 @@ export class NodeStorageInterface implements IStorage {key: string,isArray?: boolean | undefined): Promise<T | undefined> {- return this.storage[key];+ return this.storage[key] as T | undefined;}async remove(key: string): Promise<void> {@@ -98,7 +98,11 @@ export class NodeStorageInterface implements IStorage {await this.write(`userEncryptionKey`, keyData.key);}- async hash(password: string, email: string): Promise<string> {+ async hash(+ password: string,+ email: string,+ options?: { usesFallback?: boolean }+ ): Promise<string> {const APP_SALT = "oVzKtazBo7d8sb7TBvY9jw";return await this.crypto.hash(password, `${APP_SALT}${email}`);}@@ -113,19 +117,34 @@ export class NodeStorageInterface implements IStorage {password: string,salt?: string | undefined): Promise<SerializedKey> {- return { password, salt: salt || randomBytes(16).toString("base64") };+ const finalSalt = salt || randomBytes(16).toString("base64");+ return await this.crypto.exportKey(password, finalSalt);}- generateCryptoKeyPair(): Promise<SerializedKeyPair> {- throw new Error("Method not implemented.");+ async generatePGPKeyPair(): Promise<SerializedKeyPair> {+ return await this.crypto.exportKeyPair();}- generateCryptoKeyFallback(++ async generateCryptoKeyFallback(password: string,salt?: string): Promise<SerializedKey> {- throw new Error("Method not implemented.");+ return this.generateCryptoKey(password, salt);}- deriveCryptoKeyFallback(credentials: SerializedKey): Promise<void> {++ async deriveCryptoKeyFallback(_credentials: SerializedKey): Promise<void> {}++ async decryptPGPMessage(+ _privateKeyArmored: string,+ _encryptedMessage: string+ ): Promise<string> {throw new Error("Method not implemented.");}++ async validatePGPKeyPair(_keys: SerializedKeyPair): Promise<{+ isValid: boolean;+ message: string;+ }> {+ return { isValid: true, message: "ok" };+ }}diff --git a/packages/core/__tests__/crypto-primitives.test.ts b/packages/core/__tests__/crypto-primitives.test.tsnew file mode 100644index 000000000..bd5f78c3d--- /dev/null+++ b/packages/core/__tests__/crypto-primitives.test.ts@@ -0,0 +1,103 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { test, expect, describe } from "vitest";+import { databaseTest } from "./utils/index.ts";+import { randomBytes } from "../src/utils/random.js";++function validSalt() {+ return randomBytes(16).toString("base64");+}++describe("Storage encrypt/decrypt via database", () => {+ test("encrypt + decrypt round-trip through storage", async () => {+ await databaseTest().then(async (db) => {+ const key = await db.crypto().generateRandomKey();+ const plaintext = "test data for storage";+ const cipher = await db.storage().encrypt(key, plaintext);+ const decrypted = await db.storage().decrypt(key, cipher);+ expect(decrypted).toBe(plaintext);+ });+ });++ test("deriveCryptoKey stores key, getCryptoKey retrieves it", async () => {+ await databaseTest().then(async (db) => {+ const salt = validSalt();+ await db.storage().deriveCryptoKey({ password: "mypassword", salt });+ const storedKey = await db.storage().getCryptoKey();+ expect(storedKey).toBeDefined();+ expect(typeof storedKey).toBe("string");+ expect(storedKey!.length).toBeGreaterThan(0);+ });+ });++ test("generateCryptoKey returns SerializedKey", async () => {+ await databaseTest().then(async (db) => {+ const salt = validSalt();+ const generated = await db.storage().generateCryptoKey("password", salt);+ expect(generated.salt).toBe(salt);+ expect(generated.key).toBeDefined();+ });+ });++ test("generateCryptoKey without salt generates one", async () => {+ await databaseTest().then(async (db) => {+ const generated = await db.storage().generateCryptoKey("password");+ expect(generated.salt).toBeDefined();+ });+ });++ test("encrypt with derived key works after deriveCryptoKey", async () => {+ await databaseTest().then(async (db) => {+ const salt = validSalt();+ const password = "secure-password";++ await db.storage().deriveCryptoKey({ password, salt });+ const keyStr = await db.storage().getCryptoKey();++ const key = { key: keyStr!, salt };+ const plaintext = "encrypted with derived key";+ const cipher = await db.storage().encrypt(key, plaintext);+ const decrypted = await db.storage().decrypt(key, cipher);+ expect(decrypted).toBe(plaintext);+ });+ });++ test("deriveCryptoKey with empty password or salt is a no-op", async () => {+ await databaseTest().then(async (db) => {+ await db.storage().deriveCryptoKey({ password: "", salt: "salt" });+ const key = await db.storage().getCryptoKey();+ expect(key).toBeUndefined();++ await db.storage().deriveCryptoKey({ password: "pass", salt: "" });+ const key2 = await db.storage().getCryptoKey();+ expect(key2).toBeUndefined();+ });+ });++ test("encryptMulti/decryptMulti round-trip through storage", async () => {+ await databaseTest().then(async (db) => {+ const key = await db.crypto().generateRandomKey();+ const items = ["hello", "world", "test123"];+ const ciphers = await db.storage().encryptMulti(key, items);+ const decrypted = await db.storage().decryptMulti(key, ciphers);+ expect(decrypted).toEqual(items);+ });+ });+});diff --git a/packages/core/__tests__/encryption-verification.test.ts b/packages/core/__tests__/encryption-verification.test.tsnew file mode 100644index 000000000..8cbc7a075--- /dev/null+++ b/packages/core/__tests__/encryption-verification.test.ts@@ -0,0 +1,382 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { test, expect, describe, vi } from "vitest";+import { databaseTest, loginFakeUser } from "./utils/index.ts";+import { KeyManager } from "../src/api/key-manager.js";+import { randomBytes } from "../src/utils/random.js";++// ─── verifyPassword ────────────────────────────────────────────────++describe("UserManager.verifyPassword", () => {+ test("correct password returns true", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const result = await db.user.verifyPassword("password");+ expect(result).toBe(true);+ });+ });++ test("incorrect password returns false", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const result = await db.user.verifyPassword("wrongpassword");+ expect(result).toBe(false);+ });+ });++ test("no user returns false", async () => {+ await databaseTest().then(async (db) => {+ const result = await db.user.verifyPassword("anything");+ expect(result).toBe(false);+ });+ });++ test("no master key returns false", async () => {+ await databaseTest().then(async (db) => {+ const userSalt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123",+ email: "[email protected]",+ isEmailConfirmed: true,+ salt: userSalt,+ mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ const result = await db.user.verifyPassword("anything");+ expect(result).toBe(false);+ });+ });+});++// ─── verifyEncryptionKey ───────────────────────────────────────────++describe("UserManager.verifyEncryptionKey", () => {+ describe("user with both legacyDataEncryptionKey and dataEncryptionKey", () => {+ test("valid key does not throw", async () => {+ await databaseTest().then(async (db) => {+ const password = "mypassword";+ const salt = randomBytes(16).toString("base64");+ // Set up user with crypto key derived from our password+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const randomKey = await db.crypto().generateRandomKey();+ const legacyDEK = await km.wrapKey(randomKey, masterKey!);+ const dek = await km.wrapKey(randomKey, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, legacyDataEncryptionKey: legacyDEK, dataEncryptionKey: dek });++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).resolves.toBeUndefined();+ });+ });++ test("invalid key throws", async () => {+ await databaseTest().then(async (db) => {+ const password = "correct";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const randomKey = await db.crypto().generateRandomKey();+ const legacyDEK = await km.wrapKey(randomKey, masterKey!);+ const dek = await km.wrapKey(randomKey, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, legacyDataEncryptionKey: legacyDEK, dataEncryptionKey: dek });++ await expect(+ db.user.verifyEncryptionKey({ password: "wrongpassword", salt })+ ).rejects.toThrow();+ });+ });+ });++ describe("user with neither legacyDataEncryptionKey nor dataEncryptionKey", () => {+ test("valid key using attachmentsKey verifier does not throw", async () => {+ await databaseTest().then(async (db) => {+ const password = "mypassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const key = await db.crypto().generateRandomKey();+ const attachmentsKey = await km.wrapKey(key, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, attachmentsKey });++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).resolves.toBeUndefined();+ });+ });++ test("invalid key using attachmentsKey verifier throws", async () => {+ await databaseTest().then(async (db) => {+ const password = "correct";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const key = await db.crypto().generateRandomKey();+ const attachmentsKey = await km.wrapKey(key, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, attachmentsKey });++ await expect(+ db.user.verifyEncryptionKey({ password: "wrongpassword", salt })+ ).rejects.toThrow(+ "Your data cannot be decrypted using the provided encryption key."+ );+ });+ });++ test("uses monographPasswordsKey when no attachmentsKey exists", async () => {+ await databaseTest().then(async (db) => {+ const password = "mypassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const key = await db.crypto().generateRandomKey();+ const monographKey = await km.wrapKey(key, masterKey!);++ const user = await db.user.getUser();+ // Ensure no attachmentsKey, only monographPasswordsKey+ await db.user.setUser({ ...user, attachmentsKey: undefined, monographPasswordsKey: monographKey });++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).resolves.toBeUndefined();+ });+ });++ test("fetches verifier from server when no local keys exist", async () => {+ const http = (await import("../src/utils/http.js")).default;+ const mockGet = vi.spyOn(http, "get").mockResolvedValue(undefined);++ await databaseTest().then(async (db) => {+ const password = "mypassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });++ // Set a token so getAccessToken returns something+ await db.kv().write("token", {+ access_token: "fake-token",+ t: Date.now(),+ expires_in: 3600,+ scope: "notesnook.sync IdentityServerApi",+ refresh_token: "fake-refresh"+ });++ // No attachmentsKey, no monographPasswordsKey+ // Server returns undefined — should throw+ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).rejects.toThrow("Failed to fetch encryption verifier.");+ });++ mockGet.mockRestore();+ });++ test("uses server-provided verifier cipher when available", async () => {+ const http = (await import("../src/utils/http.js")).default;++ await databaseTest().then(async (db) => {+ const password = "mypassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });++ await db.kv().write("token", {+ access_token: "fake-token",+ t: Date.now(),+ expires_in: 3600,+ scope: "notesnook.sync IdentityServerApi",+ refresh_token: "fake-refresh"+ });++ // Create a verifier cipher that the correct key can decrypt+ const verifierCipher = await db.storage().encrypt(+ { password, salt },+ "test-data"+ );+ const mockGet = vi.spyOn(http, "get").mockResolvedValueOnce(verifierCipher);++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).resolves.toBeUndefined();++ expect(mockGet).toHaveBeenCalledWith(+ expect.stringContaining("/users/verifier"),+ "fake-token"+ );+ mockGet.mockRestore();+ });+ });++ test("server verifier rejects wrong key", async () => {+ const http = (await import("../src/utils/http.js")).default;++ await databaseTest().then(async (db) => {+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password: "correct-password", salt });++ await db.kv().write("token", {+ access_token: "fake-token",+ t: Date.now(),+ expires_in: 3600,+ scope: "notesnook.sync IdentityServerApi",+ refresh_token: "fake-refresh"+ });++ // Verifier encrypted with correct password+ const verifierCipher = await db.storage().encrypt(+ { password: "correct-password", salt },+ "test-data"+ );+ const mockGet = vi.spyOn(http, "get").mockResolvedValueOnce(verifierCipher);++ // Wrong key should fail verification+ await expect(+ db.user.verifyEncryptionKey({ password: "wrong-password", salt })+ ).rejects.toThrow(+ "Your data cannot be decrypted using the provided encryption key."+ );++ mockGet.mockRestore();+ });+ });+ });++ describe("user with only one of legacy DEK or DEK", () => {+ test("throws when only dataEncryptionKey exists", async () => {+ await databaseTest().then(async (db) => {+ const password = "password";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const randomKey = await db.crypto().generateRandomKey();+ const dek = await km.wrapKey(randomKey, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, dataEncryptionKey: dek });++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).rejects.toThrow(+ "Cannot verify the provided encryption key as user has only a single encryption key."+ );+ });+ });++ test("throws when only legacyDataEncryptionKey exists", async () => {+ await databaseTest().then(async (db) => {+ const password = "password";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({+ id: "user-123", email: "[email protected]", isEmailConfirmed: true,+ salt, mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+ } as any);+ await db.storage().deriveCryptoKey({ password, salt });+ const masterKey = await db.user.getMasterKey();+ const km = new KeyManager(db);++ const randomKey = await db.crypto().generateRandomKey();+ const legacyDEK = await km.wrapKey(randomKey, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, legacyDataEncryptionKey: legacyDEK });++ await expect(+ db.user.verifyEncryptionKey({ password, salt })+ ).rejects.toThrow(+ "Cannot verify the provided encryption key as user has only a single encryption key."+ );+ });+ });+ });++ describe("no user", () => {+ test("throws when no user exists", async () => {+ await databaseTest().then(async (db) => {+ await expect(+ db.user.verifyEncryptionKey({ password: "test", salt: "salt" })+ ).rejects.toThrow("User not found.");+ });+ });+ });+});diff --git a/packages/core/__tests__/key-manager.test.ts b/packages/core/__tests__/key-manager.test.tsnew file mode 100644index 000000000..fdb309be3--- /dev/null+++ b/packages/core/__tests__/key-manager.test.ts@@ -0,0 +1,274 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { test, expect, describe } from "vitest";+import { databaseTest, loginFakeUser } from "./utils/index.ts";+import { KeyManager } from "../src/api/key-manager.js";+import { randomBytes } from "../src/utils/random.js";++function validSalt() {+ return randomBytes(16).toString("base64");+}++describe("KeyManager", () => {+ describe("wrapKey + unwrapKey (symmetric key)", () => {+ test("round-trip: wrap then unwrap returns original key", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const masterKey = await db.user.getMasterKey();+ expect(masterKey).toBeDefined();++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, masterKey!);++ expect(wrapped).toBeDefined();+ expect(wrapped).toHaveProperty("cipher");++ const unwrapped = await km.unwrapKey(wrapped, masterKey!);+ expect(unwrapped).toEqual(originalKey);+ });+ });++ test("unwrap with wrong key throws", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const masterKey = await db.user.getMasterKey();+ const wrongKey = await db.storage().generateCryptoKey("wrongpassword", validSalt());++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, masterKey!);++ await expect(km.unwrapKey(wrapped, wrongKey)).rejects.toThrow();+ });+ });++ test("wrapped key is a Cipher with base64 format", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const masterKey = await db.user.getMasterKey();+ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, masterKey!);++ expect(wrapped).toHaveProperty("format", "base64");+ expect(wrapped).toHaveProperty("alg");+ expect(typeof (wrapped as any).cipher).toBe("string");+ expect(typeof (wrapped as any).iv).toBe("string");+ expect(typeof (wrapped as any).salt).toBe("string");+ });+ });+ });++ describe("rewrapKey", () => {+ test("symmetric: rewrap succeeds with new key", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);++ const oldKey = await db.storage().generateCryptoKey("oldpassword", validSalt());+ const newKey = await db.storage().generateCryptoKey("newpassword", validSalt());++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, oldKey);++ const rewrapped = await km.rewrapKey(wrapped, oldKey, newKey);++ const unwrapped = await km.unwrapKey(rewrapped, newKey);+ expect(unwrapped).toEqual(originalKey);+ });+ });++ test("symmetric: rewrap fails when unwrap with wrong old key", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);++ const correctOldKey = await db.storage().generateCryptoKey("correct", validSalt());+ const wrongOldKey = await db.storage().generateCryptoKey("wrong", validSalt());+ const newKey = await db.storage().generateCryptoKey("newpassword", validSalt());++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, correctOldKey);++ await expect(km.rewrapKey(wrapped, wrongOldKey, newKey)).rejects.toThrow();+ });+ });++ test("rewrap produces different ciphertext than original", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);++ const key1 = await db.storage().generateCryptoKey("password1", validSalt());+ const key2 = await db.storage().generateCryptoKey("password2", validSalt());++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, key1);+ const rewrapped = await km.rewrapKey(wrapped, key1, key2);++ expect((rewrapped as any).cipher).not.toBe((wrapped as any).cipher);+ expect((rewrapped as any).iv).not.toBe((wrapped as any).iv);+ });+ });+ });++ describe("get() caching", () => {+ test("get() populates cache and returns cached value", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const key1 = await km.get("attachmentsKey", { useCache: false, refetchUser: false });+ expect(key1).toBeDefined();++ const key2 = await km.get("attachmentsKey", { useCache: true, refetchUser: false });+ expect(key2).toBeDefined();+ expect(key2).toEqual(key1);+ });+ });++ test("clearCache() forces fresh fetch on next get()", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ await km.get("attachmentsKey", { useCache: true, refetchUser: false });+ km.clearCache();++ const key = await km.get("attachmentsKey", { useCache: false, refetchUser: false });+ expect(key).toBeDefined();+ });+ });+ });++ describe("get() edge cases", () => {+ test("get() returns undefined when user has no key for that ID", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const key = await km.get("dataEncryptionKey", { useCache: false, refetchUser: false });+ expect(key).toBeUndefined();+ });+ });++ test("get() returns undefined when no user exists", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);+ const key = await km.get("attachmentsKey", { useCache: false, refetchUser: false });+ expect(key).toBeUndefined();+ });+ });++ test("get() returns all key types when they exist", async () => {+ await databaseTest().then(async (db) => {+ await loginFakeUser(db);+ const km = new KeyManager(db);++ const masterKey = await db.user.getMasterKey();+ const randomKey = await db.crypto().generateRandomKey();++ const user = await db.user.getUser();+ await db.user.setUser({+ ...user,+ attachmentsKey: await km.wrapKey(randomKey, masterKey!),+ monographPasswordsKey: await km.wrapKey(randomKey, masterKey!),+ dataEncryptionKey: await km.wrapKey(randomKey, masterKey!)+ });++ const attachmentsKey = await km.get("attachmentsKey", { useCache: false, refetchUser: false });+ const monographKey = await km.get("monographPasswordsKey", { useCache: false, refetchUser: false });+ const dek = await km.get("dataEncryptionKey", { useCache: false, refetchUser: false });++ expect(attachmentsKey).toBeDefined();+ expect(monographKey).toBeDefined();+ expect(dek).toBeDefined();+ });+ });+ });++ describe("wrapKey/unwrapKey with password-derived key", () => {+ test("wrap with password key, derive same password, unwrap succeeds", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);+ const salt = validSalt();+ const passwordKey = await db.storage().generateCryptoKey("mypassword", salt);++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, passwordKey);++ const samePasswordKey = await db.storage().generateCryptoKey("mypassword", salt);+ const unwrapped = await km.unwrapKey(wrapped, samePasswordKey);+ expect(unwrapped).toEqual(originalKey);+ });+ });++ test("wrap with different password fails to unwrap", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);++ const key1 = await db.storage().generateCryptoKey("password1", validSalt());+ const key2 = await db.storage().generateCryptoKey("password2", validSalt());++ const originalKey = await db.crypto().generateRandomKey();+ const wrapped = await km.wrapKey(originalKey, key1);++ await expect(km.unwrapKey(wrapped, key2)).rejects.toThrow();+ });+ });+ });++ describe("Data integrity", () => {+ test("wrap/unwrap preserves large symmetric key", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);+ await loginFakeUser(db);++ const masterKey = await db.user.getMasterKey();+ const largeKey = await db.storage().generateCryptoKey("x".repeat(1000), validSalt());++ const wrapped = await km.wrapKey(largeKey, masterKey!);+ const unwrapped = await km.unwrapKey(wrapped, masterKey!);+ expect(unwrapped).toEqual(largeKey);+ });+ });++ test("multiple wrap/unwrap cycles with different keys", async () => {+ await databaseTest().then(async (db) => {+ const km = new KeyManager(db);++ let currentKey = await db.storage().generateCryptoKey("initial", validSalt());+ const originalData = await db.crypto().generateRandomKey();++ const key2 = await db.storage().generateCryptoKey("second", validSalt());+ const key3 = await db.storage().generateCryptoKey("third", validSalt());++ let wrapped = await km.wrapKey(originalData, currentKey);+ wrapped = await km.rewrapKey(wrapped, currentKey, key2);+ wrapped = await km.rewrapKey(wrapped, key2, key3);+ wrapped = await km.rewrapKey(wrapped, key3, currentKey);++ const unwrapped = await km.unwrapKey(wrapped, currentKey);+ expect(unwrapped).toEqual(originalData);+ });+ });+ });+});diff --git a/packages/core/__tests__/password-change.test.ts b/packages/core/__tests__/password-change.test.tsnew file mode 100644index 000000000..661b18b98--- /dev/null+++ b/packages/core/__tests__/password-change.test.ts@@ -0,0 +1,387 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { test, expect, describe, vi } from "vitest";+import { databaseTest } from "./utils/index.ts";+import { KeyManager } from "../src/api/key-manager.js";+import { randomBytes } from "../src/utils/random.js";++const FULL_USER: any = {+ id: "user-123",+ email: "[email protected]",+ isEmailConfirmed: true,+ salt: "",+ mfa: { isEnabled: false, primaryMethod: "app", remainingValidCodes: 0 },+ subscription: { appId: 0, cancelURL: null, expiry: 0, productId: null, provider: "none", start: 0, plan: "free", status: "trial", updateURL: null, googlePurchaseToken: null }+};++vi.mock("../src/utils/http.js", () => ({+ default: {+ get: vi.fn().mockResolvedValue(undefined),+ post: vi.fn().mockResolvedValue(undefined),+ patch: { json: vi.fn().mockResolvedValue(undefined) },+ delete: vi.fn().mockResolvedValue(undefined)+ }+}));++async function setupLoggedInUser(db: any, password: string = "oldpassword") {+ const salt = randomBytes(16).toString("base64");+ const user = { ...FULL_USER, salt };+ await db.user.setUser(user);+ await db.storage().deriveCryptoKey({ password, salt });++ await db.kv().write("token", {+ access_token: "fake-token",+ t: Date.now(),+ expires_in: 3600,+ scope: "notesnook.sync offline_access IdentityServerApi",+ refresh_token: "fake-refresh"+ });++ const km = new KeyManager(db);+ const masterKey = await db.user.getMasterKey();+ const randomKey = await db.crypto().generateRandomKey();++ const attachmentsKey = await km.wrapKey(randomKey, masterKey!);+ const monographPasswordsKey = await km.wrapKey(randomKey, masterKey!);+ const dek = await km.wrapKey(randomKey, masterKey!);+ const legacyDEK = await km.wrapKey(randomKey, masterKey!);++ await db.user.setUser({+ ...user,+ attachmentsKey,+ monographPasswordsKey,+ dataEncryptionKey: dek,+ legacyDataEncryptionKey: legacyDEK+ });++ return { password, salt, masterKey, randomKey };+}++// ─── _updatePassword (change) ──────────────────────────────────────++describe("UserManager._updatePassword (change)", () => {+ test("successful password change rewraps all keys and derives new master key", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ const result = await db.user.changePassword("oldpassword", "newpassword");+ expect(result).toBe(true);+ const newMasterKey = await db.user.getMasterKey();+ expect(newMasterKey).toBeDefined();+ expect(newMasterKey!.key).not.toBe("");+ });+ });++ test("wrong old password throws 'Incorrect old password'", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ await expect(+ db.user.changePassword("wrongpassword", "newpassword")+ ).rejects.toThrow("Incorrect old password");+ });+ });++ test("empty new password throws 'New password is required'", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ await expect(+ db.user.changePassword("oldpassword", "")+ ).rejects.toThrow("New password is required");+ });+ });++ test("no logged in user throws", async () => {+ await databaseTest().then(async (db) => {+ await expect(+ db.user.changePassword("oldpassword", "newpassword")+ ).rejects.toThrow();+ });+ });++ test("keys are rewrapped: old master key can no longer unwrap", async () => {+ await databaseTest().then(async (db) => {+ const { masterKey: oldMasterKey } = await setupLoggedInUser(db, "oldpassword");+ await db.user.changePassword("oldpassword", "newpassword");++ const user = await db.user.getUser();+ const km = new KeyManager(db);++ if (user.attachmentsKey) {+ await expect(+ km.unwrapKey(user.attachmentsKey, oldMasterKey!)+ ).rejects.toThrow();+ }+ });+ });++ test("new master key can unwrap all rewrapped keys", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ await db.user.changePassword("oldpassword", "newpassword");++ const newMasterKey = await db.user.getMasterKey();+ const user = await db.user.getUser();+ const km = new KeyManager(db);++ if (user.attachmentsKey) {+ const key = await km.unwrapKey(user.attachmentsKey, newMasterKey!);+ expect(key).toBeDefined();+ }+ if (user.monographPasswordsKey) {+ const key = await km.unwrapKey(user.monographPasswordsKey, newMasterKey!);+ expect(key).toBeDefined();+ }+ if (user.dataEncryptionKey) {+ const key = await km.unwrapKey(user.dataEncryptionKey, newMasterKey!);+ expect(key).toBeDefined();+ }+ if (user.legacyDataEncryptionKey) {+ const key = await km.unwrapKey(user.legacyDataEncryptionKey, newMasterKey!);+ expect(key).toBeDefined();+ }+ });+ });++ test("rewrapped user keys are stored with new ciphertext", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ const km = new KeyManager(db);++ // Fetch the attachmentsKey BEFORE password change+ const oldKey = await km.get("attachmentsKey", {+ useCache: false,+ refetchUser: false+ });+ expect(oldKey).toBeDefined();+ const oldCipher = (oldKey as any).cipher;++ // Change password — keys are rewrapped and user is updated+ await db.user.changePassword("oldpassword", "newpassword");++ // The new user object in KV should have a rewrapped attachmentsKey+ // (with new ciphertext)+ const newKey = await km.get("attachmentsKey", {+ useCache: false,+ refetchUser: false+ });+ expect(newKey).toBeDefined();+ // The re-fetched cipher MUST differ from the old one because the key+ // was re-wrapped with a new master key (different ciphertext).+ expect((newKey as any).cipher).not.toBe(oldCipher);++ // Verify the new key can be unwrapped with the new master key+ const newMasterKey = await db.user.getMasterKey();+ const unwrapped = await km.unwrapKey(newKey, newMasterKey!);+ expect(unwrapped).toBeDefined();+ });+ });+});++// ─── _updatePassword (reset) ───────────────────────────────────────++describe("UserManager._updatePassword (reset)", () => {+ test("successful reset with explicit encryption key", async () => {+ await databaseTest().then(async (db) => {+ const { password, salt } = await setupLoggedInUser(db, "oldpassword");+ const result = await db.user.resetPassword({+ newPassword: "newpassword",+ encryptionKey: { password, salt }+ });+ expect(result).toBe(true);+ const newMasterKey = await db.user.getMasterKey();+ expect(newMasterKey).toBeDefined();+ });+ });++ test("reset without encryption key throws", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ await expect(+ db.user.resetPassword({ newPassword: "newpassword" } as any)+ ).rejects.toThrow("Encryption key is required.");+ });+ });++ test("empty new password throws 'New password is required'", async () => {+ await databaseTest().then(async (db) => {+ const { password, salt } = await setupLoggedInUser(db, "oldpassword");+ await expect(+ db.user.resetPassword({ newPassword: "", encryptionKey: { password, salt } })+ ).rejects.toThrow("New password is required");+ });+ });++ test("reset with wrong encryption key throws during verification", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ await expect(+ db.user.resetPassword({+ newPassword: "newpassword",+ encryptionKey: { password: "wrongpassword", salt: "wrongsalt" }+ })+ ).rejects.toThrow();+ });+ });+});++// ─── Key migration scenarios ───────────────────────────────────────++describe("Key migration during password change", () => {+ test("legacy user (no DEK, no legacy DEK) gets new DEK and legacy DEK created", async () => {+ await databaseTest().then(async (db) => {+ const password = "oldpassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({ ...FULL_USER, salt });+ await db.storage().deriveCryptoKey({ password, salt });++ await db.kv().write("token", {+ access_token: "fake-token", t: Date.now(), expires_in: 3600,+ scope: "notesnook.sync offline_access IdentityServerApi", refresh_token: "fake-refresh"+ });++ const km = new KeyManager(db);+ const masterKey = await db.user.getMasterKey();+ const randomKey = await db.crypto().generateRandomKey();+ const attachmentsKey = await km.wrapKey(randomKey, masterKey!);++ await db.user.setUser({ ...FULL_USER, salt, attachmentsKey });++ const result = await db.user.changePassword("oldpassword", "newpassword");+ expect(result).toBe(true);++ const user = await db.user.getUser();+ expect(user.dataEncryptionKey).toBeDefined();+ expect(user.legacyDataEncryptionKey).toBeDefined();+ });+ });++ test("user with both DEK and legacy DEK: both are rewrapped", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");+ const userBefore = await db.user.getUser();+ const originalDEKCipher = userBefore.dataEncryptionKey?.cipher;+ const originalLegacyDEKCipher = userBefore.legacyDataEncryptionKey?.cipher;++ await db.user.changePassword("oldpassword", "newpassword");++ const userAfter = await db.user.getUser();+ expect(userAfter.dataEncryptionKey?.cipher).not.toBe(originalDEKCipher);+ expect(userAfter.legacyDataEncryptionKey?.cipher).not.toBe(originalLegacyDEKCipher);+ });+ });++ test("user with only DEK (no legacy): password change fails verification", async () => {+ await databaseTest().then(async (db) => {+ const password = "oldpassword";+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({ ...FULL_USER, salt });+ await db.storage().deriveCryptoKey({ password, salt });++ await db.kv().write("token", {+ access_token: "fake-token", t: Date.now(), expires_in: 3600,+ scope: "notesnook.sync offline_access IdentityServerApi", refresh_token: "fake-refresh"+ });++ const km = new KeyManager(db);+ const masterKey = await db.user.getMasterKey();+ const randomKey = await db.crypto().generateRandomKey();+ const dek = await km.wrapKey(randomKey, masterKey!);++ await db.user.setUser({ ...FULL_USER, salt, dataEncryptionKey: dek });++ // verifyEncryptionKey throws when only one of legacy DEK or DEK exists+ await expect(+ db.user.changePassword("oldpassword", "newpassword")+ ).rejects.toThrow(+ "Cannot verify the provided encryption key as user has only a single encryption key."+ );+ });+ });++ test("inbox keys are rewrapped during password change", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db, "oldpassword");++ const km = new KeyManager(db);+ const masterKey = await db.user.getMasterKey();+ // Use a fake keypair since generatePGPKeyPair depends on unavailable sodium API+ const fakeKeyPair = { publicKey: "fake-public-key", privateKey: "fake-private-key" };+ const wrappedInboxKeys = await km.wrapKey(fakeKeyPair as any, masterKey!);++ const user = await db.user.getUser();+ await db.user.setUser({ ...user, inboxKeys: wrappedInboxKeys });++ await db.user.changePassword("oldpassword", "newpassword");++ const userAfter = await db.user.getUser();+ const newMasterKey = await db.user.getMasterKey();+ expect(userAfter.inboxKeys).toBeDefined();+ const unwrappedKeypair = await km.unwrapKey(userAfter.inboxKeys, newMasterKey!);+ expect((unwrappedKeypair as any).publicKey).toBe(fakeKeyPair.publicKey);+ expect((unwrappedKeypair as any).privateKey).toBe(fakeKeyPair.privateKey);+ });+ });+});++// ─── getDataEncryptionKeys ─────────────────────────────────────────++describe("UserManager.getDataEncryptionKeys", () => {+ test("returns LEGACY version when no DEK exists", async () => {+ await databaseTest().then(async (db) => {+ const salt = randomBytes(16).toString("base64");+ await db.user.setUser({ ...FULL_USER, salt });+ await db.storage().deriveCryptoKey({ password: "password", salt });++ const keys = await db.user.getDataEncryptionKeys();+ expect(keys).toBeDefined();+ expect(keys!.length).toBe(1);+ expect(keys![0].version).toBe(0); // KEY_VERSION.LEGACY+ });+ });++ test("returns DEK version when DEK exists", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db);+ const keys = await db.user.getDataEncryptionKeys();+ expect(keys).toBeDefined();+ expect(keys!.length).toBeGreaterThanOrEqual(1);+ const dekVersion = keys!.find((k: any) => k.version === 1);+ expect(dekVersion).toBeDefined();+ });+ });++ test("returns both LEGACY and DEK when both exist", async () => {+ await databaseTest().then(async (db) => {+ await setupLoggedInUser(db);+ const keys = await db.user.getDataEncryptionKeys();+ expect(keys).toBeDefined();+ expect(keys!.length).toBe(2);+ const versions = keys!.map((k: any) => k.version);+ expect(versions).toContain(0);+ expect(versions).toContain(1);+ });+ });++ test("returns undefined when no master key exists", async () => {+ await databaseTest().then(async (db) => {+ const keys = await db.user.getDataEncryptionKeys();+ expect(keys).toBeUndefined();+ });+ });+});diff --git a/packages/crypto/__tests__/crypto.test.ts b/packages/crypto/__tests__/crypto.test.tsnew file mode 100644index 000000000..e6d407e3a--- /dev/null+++ b/packages/crypto/__tests__/crypto.test.ts@@ -0,0 +1,276 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { test, expect, describe } from "vitest";+import { NNCrypto } from "../src/index.js";+import { randomBytes } from "crypto";++const crypto = new NNCrypto();++function validSalt() {+ return randomBytes(16).toString("base64");+}++// ─── Key Derivation ────────────────────────────────────────────────++describe("KeyUtils.deriveKey", () => {+ test("same password + salt produces same key", async () => {+ const salt = validSalt();+ const key1 = await crypto.deriveKey("password123", salt);+ const key2 = await crypto.deriveKey("password123", salt);+ expect(key1.key).toEqual(key2.key);+ expect(key1.salt).toBe(key2.salt);+ });++ test("different passwords produce different keys", async () => {+ const salt = validSalt();+ const key1 = await crypto.deriveKey("password1", salt);+ const key2 = await crypto.deriveKey("password2", salt);+ expect(key1.key).not.toEqual(key2.key);+ });++ test("different salts produce different keys", async () => {+ const salt1 = validSalt();+ const salt2 = validSalt();+ const key1 = await crypto.deriveKey("password", salt1);+ const key2 = await crypto.deriveKey("password", salt2);+ expect(key1.key).not.toEqual(key2.key);+ });++ test("without salt generates a random salt", async () => {+ const key1 = await crypto.deriveKey("password");+ const key2 = await crypto.deriveKey("password");+ expect(key1.salt).not.toBe(key2.salt);+ expect(key1.key).not.toEqual(key2.key);+ });++ test("exportKey returns SerializedKey with base64 key and salt", async () => {+ const salt = validSalt();+ const exported = await crypto.exportKey("password", salt);+ expect(exported.key).toBeDefined();+ expect(exported.salt).toBe(salt);+ expect(typeof exported.key).toBe("string");+ expect(exported.key!.length).toBeGreaterThan(0);+ });++ test("exportKey without salt generates one", async () => {+ const exported = await crypto.exportKey("password");+ expect(exported.key).toBeDefined();+ expect(exported.salt).toBeDefined();+ expect(typeof exported.salt).toBe("string");+ });++ test("deriveKey produces 32-byte key", async () => {+ const salt = validSalt();+ const key = await crypto.deriveKey("password", salt);+ // libsodium crypto_aead_xchacha20poly1305_ietf_KEYBYTES = 32+ expect(key.key.length).toBe(32);+ });+});++// ─── Symmetric Encryption Round-Trip ───────────────────────────────++describe("Encryption/Decryption round-trip", () => {+ test("text encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const plaintext = "Hello, Notesnook!";+ const cipher = await crypto.encrypt(key, plaintext, "text", "base64");++ expect(cipher.cipher).toBeDefined();+ expect(cipher.iv).toBeDefined();+ expect(cipher.salt).toBeDefined();+ expect(cipher.format).toBe("base64");+ expect(cipher.alg).toContain("xcha");+ expect(cipher.length).toBe(plaintext.length);++ const decrypted = await crypto.decrypt(key, cipher, "text");+ expect(decrypted).toBe(plaintext);+ });++ test("base64 input encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const plaintext = "SGVsbG8gV29ybGQ=";+ const cipher = await crypto.encrypt(key, plaintext, "base64", "base64");+ const decrypted = await crypto.decrypt(key, cipher, "base64");+ expect(decrypted).toBe(plaintext);+ });++ test("empty string encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const plaintext = "";+ const cipher = await crypto.encrypt(key, plaintext, "text", "base64");+ const decrypted = await crypto.decrypt(key, cipher, "text");+ expect(decrypted).toBe(plaintext);+ });++ test("unicode string encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const plaintext = "Hello \u{1F30D}! Testing \u{00E9}mojis and \u{65E5}\u{672C}\u{8A9E}";+ const cipher = await crypto.encrypt(key, plaintext, "text", "base64");+ const decrypted = await crypto.decrypt(key, cipher, "text");+ expect(decrypted).toBe(plaintext);+ });++ test("long text encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const plaintext = "A".repeat(100000);+ const cipher = await crypto.encrypt(key, plaintext, "text", "base64");+ const decrypted = await crypto.decrypt(key, cipher, "text");+ expect(decrypted).toBe(plaintext);+ });++ test("decrypt with wrong key throws", async () => {+ const salt = validSalt();+ const key1 = await crypto.exportKey("password1", salt);+ const key2 = await crypto.exportKey("password2", salt);+ const cipher = await crypto.encrypt(key1, "secret", "text", "base64");++ await expect(crypto.decrypt(key2, cipher, "text")).rejects.toThrow();+ });++ test("each encryption produces unique ciphertext (random nonce)", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const cipher1 = await crypto.encrypt(key, "same data", "text", "base64");+ const cipher2 = await crypto.encrypt(key, "same data", "text", "base64");+ expect(cipher1.cipher).not.toBe(cipher2.cipher);+ expect(cipher1.iv).not.toBe(cipher2.iv);+ });++ test("cipher with salt in key but no salt on key uses cipher salt", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const cipher = await crypto.encrypt(key, "data", "text", "base64");++ // key without salt - should use cipher's salt+ const keyWithoutSalt = { key: key.key };+ const decrypted = await crypto.decrypt(keyWithoutSalt, cipher, "text");+ expect(decrypted).toBe("data");+ });+});++// ─── Multi-Encryption ──────────────────────────────────────────────++describe("encryptMulti / decryptMulti round-trip", () => {+ test("multiple items encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const items = ["item1", "item2", "item3", "hello world"];+ const ciphers = await crypto.encryptMulti(key, items, "text", "base64");++ expect(ciphers.length).toBe(items.length);++ const decrypted = await crypto.decryptMulti(key, ciphers, "text");+ expect(decrypted).toEqual(items);+ });++ test("empty array encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());+ const ciphers = await crypto.encryptMulti(key, [], "text", "base64");+ expect(ciphers.length).toBe(0);++ const decrypted = await crypto.decryptMulti(key, ciphers, "text");+ expect(decrypted.length).toBe(0);+ });+});++// ─── Password Hashing ──────────────────────────────────────────────++describe("Password.hash", () => {+ test("same password + salt produces same hash", async () => {+ const hash1 = await crypto.hash("mypassword", "[email protected]");+ const hash2 = await crypto.hash("mypassword", "[email protected]");+ expect(hash1).toBe(hash2);+ });++ test("different passwords produce different hashes", async () => {+ const hash1 = await crypto.hash("password1", "[email protected]");+ const hash2 = await crypto.hash("password2", "[email protected]");+ expect(hash1).not.toBe(hash2);+ });++ test("different salts produce different hashes", async () => {+ const hash1 = await crypto.hash("password", "[email protected]");+ const hash2 = await crypto.hash("password", "[email protected]");+ expect(hash1).not.toBe(hash2);+ });++ test("hash is a non-empty string", async () => {+ const hash = await crypto.hash("password", "[email protected]");+ expect(typeof hash).toBe("string");+ expect(hash.length).toBeGreaterThan(0);+ });++ test("empty password produces a hash", async () => {+ const hash = await crypto.hash("", "[email protected]");+ expect(typeof hash).toBe("string");+ expect(hash.length).toBeGreaterThan(0);+ });+});++// ─── Streaming Encryption ──────────────────────────────────────────++describe("Streaming Encryption/Decryption", () => {+ test("stream encrypt + decrypt round-trip", async () => {+ const key = await crypto.exportKey("testpassword", validSalt());++ const { iv, stream: encryptStream } =+ await crypto.createEncryptionStream(key);++ const encoder = new TextEncoder();+ const chunks: Uint8Array[] = [];++ const writer = encryptStream.writable.getWriter();+ const reader = encryptStream.readable.getReader();++ writer.write({ data: encoder.encode("chunk1-"), final: false });+ writer.write({ data: encoder.encode("chunk2-"), final: false });+ writer.write({ data: encoder.encode("chunk3-final"), final: true });++ while (true) {+ const { value, done } = await reader.read();+ if (done) break;+ chunks.push(value);+ }++ const decryptStream = await crypto.createDecryptionStream(key, iv);+ const decryptWriter = decryptStream.writable.getWriter();+ const decryptReader = decryptStream.readable.getReader();++ for (const chunk of chunks) {+ decryptWriter.write(chunk);+ }++ const decryptedChunks: Uint8Array[] = [];+ while (true) {+ const { value, done } = await decryptReader.read();+ if (done) break;+ decryptedChunks.push(value);+ }++ const decrypted = new Uint8Array(+ decryptedChunks.reduce((acc, chunk) => acc + chunk.length, 0)+ );+ let offset = 0;+ for (const chunk of decryptedChunks) {+ decrypted.set(chunk, offset);+ offset += chunk.length;+ }++ const decoder = new TextDecoder();+ expect(decoder.decode(decrypted)).toBe("chunk1-chunk2-chunk3-final");+ });+});diff --git a/packages/crypto/package-lock.json b/packages/crypto/package-lock.jsonindex 3c74db4d9..930425367 100644--- a/packages/crypto/package-lock.json+++ b/packages/crypto/package-lock.json@@ -11,7 +11,9 @@"dependencies": {"@notesnook/sodium": "file:../sodium"},- "devDependencies": {}+ "devDependencies": {+ "vitest": "2.1.8"+ }},"../sodium": {"name": "@notesnook/sodium",@@ -32,9 +34,1459 @@"sodium-native": ">=4"}},+ "node_modules/@esbuild/aix-ppc64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",+ "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "aix"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-arm": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",+ "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",+ "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",+ "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/darwin-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",+ "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/darwin-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",+ "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/freebsd-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",+ "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/freebsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",+ "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-arm": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",+ "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",+ "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-ia32": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",+ "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-loong64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",+ "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",+ "cpu": [+ "loong64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-mips64el": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",+ "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",+ "cpu": [+ "mips64el"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-ppc64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",+ "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-riscv64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",+ "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-s390x": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",+ "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",+ "cpu": [+ "s390x"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",+ "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/netbsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",+ "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "netbsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/openbsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",+ "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openbsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/sunos-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",+ "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "sunos"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",+ "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-ia32": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",+ "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",+ "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@jridgewell/sourcemap-codec": {+ "version": "1.5.5",+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@napi-rs/lzma-linux-x64-gnu": {+ "version": "1.5.1",+ "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",+ "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": "^22.20 || ^24.12 || >=25"+ }+ },"node_modules/@notesnook/sodium": {"resolved": "../sodium","link": true+ },+ "node_modules/@rollup/rollup-android-arm-eabi": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.4.tgz",+ "integrity": "sha512-RrPokAb7dmbxFoeO3TloqHyOjgye8RkBhSqmp4aJMIex4c9r46ZstPnleDQOq1t46VOVjwIuwNogIqbodV1Vvg==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ]+ },+ "node_modules/@rollup/rollup-android-arm64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.4.tgz",+ "integrity": "sha512-JKuJc+pnpks2pjy7L/N3v/cAkZxYlnmuZoD840ldbMI5KDbC4iO9NKwPKYdjYFCMAIIlBzYSFHxIJVYzRo2/8A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ]+ },+ "node_modules/@rollup/rollup-darwin-arm64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.4.tgz",+ "integrity": "sha512-krw5uS2STmvJ02x0uTXHbqQNuz+9eZ1iw+qXk9dmW2gvV4jV7O2hEoOnuhFrpOPiel1mBFtqbxYZZtC46hXLOw==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ]+ },+ "node_modules/@rollup/rollup-darwin-x64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.4.tgz",+ "integrity": "sha512-wsTxtgApb4PrOsNJIm0FZ1h3WvCC+k9uxLJ4ad75hgoS4NiRes2SoJFlDAyMwiUY8IssDqGcHbXuN0sx1tfF1A==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ]+ },+ "node_modules/@rollup/rollup-freebsd-arm64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.4.tgz",+ "integrity": "sha512-GUOnQlyZe3yAXhWOtOMsn5Qkrv5E5mZXa0thbARWi5Ei2szlVXJFQhddZ4HbAzh8q92w5twp+CQvs/eFanz9YQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ]+ },+ "node_modules/@rollup/rollup-freebsd-x64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.4.tgz",+ "integrity": "sha512-/Y7f3QuxjzPKsjA/rfEDa3+0vXqyjmJ50Ln8dPpCmWkKTrUoWHG1cWhTqaAMLob2m2nESWuC7yGrREz019Ztqg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm-gnueabihf": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.4.tgz",+ "integrity": "sha512-81wiiX3v7aqy+T+bT61TJ78yJjRquqFFTTbAPt08imfQQzkPIW8t6aJbkTagtCCrXMNc9D66+geqlK7ydLPNqA==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm-musleabihf": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.4.tgz",+ "integrity": "sha512-9kmDIvNZqdoHOBZgNtpTBeLWYO/LVipM3H/j62P8848/l/VPEQL6N3uxU9pvP1oZAsXyC2MEnFP3ovRjo7WYNQ==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.4.tgz",+ "integrity": "sha512-CcnXHWnXg69g+DX5VWL3FHts3qMRN2uVEHX+BZvGLdd07/gXkn3ePjYtO1LDJvxkGKVHMclKBRa1QUTH+6toYQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm64-musl": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.4.tgz",+ "integrity": "sha512-iFOibiHnTRuhrWLlRsOQFdZJJIa7S8OwkneJr4ocALP16u5yk6lWLINFwhHaEqBFMsKDUZofLkGos7+CPzGB3g==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-loong64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.4.tgz",+ "integrity": "sha512-XnWYMI7euHlb5a871xPja+Gm7DRCFU+FGRrtS2sMq9N8FvqtpagUy6gD4YOemC5MRk9xbh8+jYMEJbigFQwsgA==",+ "cpu": [+ "loong64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-loong64-musl": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.4.tgz",+ "integrity": "sha512-qGDAlO0U8xedCcsdRm9oaoQY8DAx/QT7uIxJWhCdx0ceIWX783UC9QSYkdpzAe29wNiVfp24+bZdQmn49o45SQ==",+ "cpu": [+ "loong64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-ppc64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.4.tgz",+ "integrity": "sha512-ru4H6ezD7ysA5EiEK6qkkaEb4modH8CTej6kUy/gQi20u3kB3G7Zn8snXXkeJSCOFKG/rbPPtM/+9Wgas1961w==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-ppc64-musl": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.4.tgz",+ "integrity": "sha512-2W4MO5WQVJnbJaZdvDb9rhBDuFU1nKIepPFpJUBsTh2k1YY2g+ODViaWuyOAjQ5cOP7NvrvLzt3wvHOoiAvc7w==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-riscv64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.4.tgz",+ "integrity": "sha512-+fxjfuoAmVMCYV5QyjoIpu0cp5DOiOTeqYFk1AVaxGr+/ravWLX89XfQmptsoWcaVy/TGf2hexzbUOrCQIL1CQ==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-riscv64-musl": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.4.tgz",+ "integrity": "sha512-jTn8JfHGL4djjFxPuM06LmNUJDsst2jeVlsd9OmIH6zc5sC9K6rIuO4YajXatLUpBmBKl6b35ro1QZocLi+tcA==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-s390x-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.4.tgz",+ "integrity": "sha512-oCJCJL4pXsoDcP2QZ+JVlPTIRc6266zsIaeJJsWImmF7HO0W8nb6HuSgZlMWxJwaPf8ehbSw8yo0EUw925hKsA==",+ "cpu": [+ "s390x"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-x64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.4.tgz",+ "integrity": "sha512-W69hukhZ3KKNRCaMIEzKvcFye42hh0FE1+YoYaf5+Ikacuftoco6yO/xouz0hc5d5W/s3yBro5jRiuEE/Q5vUw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-x64-musl": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.4.tgz",+ "integrity": "sha512-qiXbGG2jkjXhzXpsFZSR2Xpb8DN/UaxYsbb/STbuR/6fpaDgRmmaq1B/LmtF2wQFOFOSsK2jdE0RZ3a0zHn4QA==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-openbsd-x64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.4.tgz",+ "integrity": "sha512-nWeM//hxv8mIo6jD7Hu4o48DVmV9pbV6gsKaWU+4NFyqHoPKwrkRiZGLKUhOBk8qNmDmpwFtPKg80Bo/Tn4xiQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openbsd"+ ]+ },+ "node_modules/@rollup/rollup-openharmony-arm64": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.4.tgz",+ "integrity": "sha512-s62SQ/vgsRSvMwDkOEfTqfgASF0f26ZNaQuTA6Aok5lrikf89yI2W0gFHvZb2Jpgc6N8JnOKZgCK2iciO3CsxQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openharmony"+ ]+ },+ "node_modules/@rollup/rollup-win32-arm64-msvc": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.4.tgz",+ "integrity": "sha512-J6wGf8TVGbXJq+HH+ttTvrcfNKPbuZecV6KT1B8I18BC5IURUh5kl4Yl5OEP5eFIUoI5BWxCsyYMhFsDx8kekw==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-ia32-msvc": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.4.tgz",+ "integrity": "sha512-zmfrQd/0wu6oJs8Vq8KwY/YtsKSsLtKe/HwAP4Wqy8LhWjeT55fHRAkOhYQ12wI3ayS4Tt12d5CDRD7N96SAYQ==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-x64-gnu": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.4.tgz",+ "integrity": "sha512-qPzHqdj9rfUD+w79dtE07zi/kFwKyCJqplp5K5ygeLTp7jLpAoc16OAH39HSmRC9UpozaecsleI8uAdEj6v2yw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-x64-msvc": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.4.tgz",+ "integrity": "sha512-zD6NdeWEByGE9QF9vCrlJ5YQB4oq9q91kPZS37Jwj5hOkvR1lTBSpsKhKDw4IJtbQ35LsTS1HD9DZYGKIshU1Q==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@types/estree": {+ "version": "1.0.9",+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",+ "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@vitest/expect": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.8.tgz",+ "integrity": "sha512-8ytZ/fFHq2g4PJVAtDX57mayemKgDR6X3Oa2Foro+EygiOJHUXhCqBAAKQYYajZpFoIfvBCF1j6R6IYRSIUFuw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/spy": "2.1.8",+ "@vitest/utils": "2.1.8",+ "chai": "^5.1.2",+ "tinyrainbow": "^1.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/mocker": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.8.tgz",+ "integrity": "sha512-7guJ/47I6uqfttp33mgo6ga5Gr1VnL58rcqYKyShoRK9ebu8T5Rs6HN3s1NABiBeVTdWNrwUMcHH54uXZBN4zA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/spy": "2.1.8",+ "estree-walker": "^3.0.3",+ "magic-string": "^0.30.12"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ },+ "peerDependencies": {+ "msw": "^2.4.9",+ "vite": "^5.0.0"+ },+ "peerDependenciesMeta": {+ "msw": {+ "optional": true+ },+ "vite": {+ "optional": true+ }+ }+ },+ "node_modules/@vitest/pretty-format": {+ "version": "2.1.9",+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",+ "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tinyrainbow": "^1.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/runner": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.8.tgz",+ "integrity": "sha512-17ub8vQstRnRlIU5k50bG+QOMLHRhYPAna5tw8tYbj+jzjcspnwnwtPtiOlkuKC4+ixDPTuLZiqiWWQ2PSXHVg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/utils": "2.1.8",+ "pathe": "^1.1.2"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/snapshot": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.8.tgz",+ "integrity": "sha512-20T7xRFbmnkfcmgVEz+z3AU/3b0cEzZOt/zmnvZEctg64/QZbSDJEVm9fLnnlSi74KibmRsO9/Qabi+t0vCRPg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/pretty-format": "2.1.8",+ "magic-string": "^0.30.12",+ "pathe": "^1.1.2"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/snapshot/node_modules/@vitest/pretty-format": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.8.tgz",+ "integrity": "sha512-9HiSZ9zpqNLKlbIDRWOnAWqgcA7xu+8YxXSekhr0Ykab7PAYFkhkwoqVArPOtJhPmYeE2YHgKZlj3CP36z2AJQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tinyrainbow": "^1.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/spy": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.8.tgz",+ "integrity": "sha512-5swjf2q95gXeYPevtW0BLk6H8+bPlMb4Vw/9Em4hFxDcaOxS+e0LOX4yqNxoHzMR2akEB2xfpnWUzkZokmgWDg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tinyspy": "^3.0.2"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/utils": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.8.tgz",+ "integrity": "sha512-dwSoui6djdwbfFmIgbIjX2ZhIoG7Ex/+xpxyiEgIGzjliY8xGkcpITKTlp6B4MgtGkF2ilvm97cPM96XZaAgcA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/pretty-format": "2.1.8",+ "loupe": "^3.1.2",+ "tinyrainbow": "^1.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/utils/node_modules/@vitest/pretty-format": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.8.tgz",+ "integrity": "sha512-9HiSZ9zpqNLKlbIDRWOnAWqgcA7xu+8YxXSekhr0Ykab7PAYFkhkwoqVArPOtJhPmYeE2YHgKZlj3CP36z2AJQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tinyrainbow": "^1.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/assertion-error": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",+ "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/cac": {+ "version": "6.7.14",+ "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",+ "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/chai": {+ "version": "5.3.3",+ "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",+ "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "assertion-error": "^2.0.1",+ "check-error": "^2.1.1",+ "deep-eql": "^5.0.1",+ "loupe": "^3.1.0",+ "pathval": "^2.0.0"+ },+ "engines": {+ "node": ">=18"+ }+ },+ "node_modules/check-error": {+ "version": "2.1.3",+ "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",+ "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 16"+ }+ },+ "node_modules/debug": {+ "version": "4.4.3",+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "ms": "^2.1.3"+ },+ "engines": {+ "node": ">=6.0"+ },+ "peerDependenciesMeta": {+ "supports-color": {+ "optional": true+ }+ }+ },+ "node_modules/deep-eql": {+ "version": "5.0.2",+ "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",+ "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6"+ }+ },+ "node_modules/es-module-lexer": {+ "version": "1.7.0",+ "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",+ "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/esbuild": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",+ "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",+ "dev": true,+ "hasInstallScript": true,+ "license": "MIT",+ "bin": {+ "esbuild": "bin/esbuild"+ },+ "engines": {+ "node": ">=12"+ },+ "optionalDependencies": {+ "@esbuild/aix-ppc64": "0.21.5",+ "@esbuild/android-arm": "0.21.5",+ "@esbuild/android-arm64": "0.21.5",+ "@esbuild/android-x64": "0.21.5",+ "@esbuild/darwin-arm64": "0.21.5",+ "@esbuild/darwin-x64": "0.21.5",+ "@esbuild/freebsd-arm64": "0.21.5",+ "@esbuild/freebsd-x64": "0.21.5",+ "@esbuild/linux-arm": "0.21.5",+ "@esbuild/linux-arm64": "0.21.5",+ "@esbuild/linux-ia32": "0.21.5",+ "@esbuild/linux-loong64": "0.21.5",+ "@esbuild/linux-mips64el": "0.21.5",+ "@esbuild/linux-ppc64": "0.21.5",+ "@esbuild/linux-riscv64": "0.21.5",+ "@esbuild/linux-s390x": "0.21.5",+ "@esbuild/linux-x64": "0.21.5",+ "@esbuild/netbsd-x64": "0.21.5",+ "@esbuild/openbsd-x64": "0.21.5",+ "@esbuild/sunos-x64": "0.21.5",+ "@esbuild/win32-arm64": "0.21.5",+ "@esbuild/win32-ia32": "0.21.5",+ "@esbuild/win32-x64": "0.21.5"+ }+ },+ "node_modules/estree-walker": {+ "version": "3.0.3",+ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",+ "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/estree": "^1.0.0"+ }+ },+ "node_modules/expect-type": {+ "version": "1.4.0",+ "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",+ "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",+ "dev": true,+ "license": "Apache-2.0",+ "engines": {+ "node": ">=12.0.0"+ }+ },+ "node_modules/fsevents": {+ "version": "2.3.3",+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",+ "dev": true,+ "hasInstallScript": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"+ }+ },+ "node_modules/loupe": {+ "version": "3.2.1",+ "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",+ "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/magic-string": {+ "version": "0.30.21",+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",+ "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@jridgewell/sourcemap-codec": "^1.5.5"+ }+ },+ "node_modules/ms": {+ "version": "2.1.3",+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/nanoid": {+ "version": "3.3.18",+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",+ "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/ai"+ }+ ],+ "license": "MIT",+ "bin": {+ "nanoid": "bin/nanoid.cjs"+ },+ "engines": {+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"+ }+ },+ "node_modules/pathe": {+ "version": "1.1.2",+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",+ "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/pathval": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",+ "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 14.16"+ }+ },+ "node_modules/picocolors": {+ "version": "1.1.1",+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",+ "dev": true,+ "license": "ISC"+ },+ "node_modules/postcss": {+ "version": "8.5.26",+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz",+ "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==",+ "dev": true,+ "funding": [+ {+ "type": "opencollective",+ "url": "https://opencollective.com/postcss/"+ },+ {+ "type": "tidelift",+ "url": "https://tidelift.com/funding/github/npm/postcss"+ },+ {+ "type": "github",+ "url": "https://github.com/sponsors/ai"+ }+ ],+ "license": "MIT",+ "dependencies": {+ "nanoid": "^3.3.17",+ "picocolors": "^1.1.1",+ "source-map-js": "^1.2.1"+ },+ "engines": {+ "node": "^10 || ^12 || >=14"+ }+ },+ "node_modules/rollup": {+ "version": "4.62.4",+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.4.tgz",+ "integrity": "sha512-RXOqwaPsBGjMNMa4sQjDjHieHEZDFoj/Rdr46l2MU5DfEs16wHJPC2RPTPHWhNl+M3aI472LLqFkFKut4SblOg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/estree": "1.0.9"+ },+ "bin": {+ "rollup": "dist/bin/rollup"+ },+ "engines": {+ "node": ">=18.0.0",+ "npm": ">=8.0.0"+ },+ "optionalDependencies": {+ "@napi-rs/lzma-linux-x64-gnu": "1.5.1",+ "@rollup/rollup-android-arm-eabi": "4.62.4",+ "@rollup/rollup-android-arm64": "4.62.4",+ "@rollup/rollup-darwin-arm64": "4.62.4",+ "@rollup/rollup-darwin-x64": "4.62.4",+ "@rollup/rollup-freebsd-arm64": "4.62.4",+ "@rollup/rollup-freebsd-x64": "4.62.4",+ "@rollup/rollup-linux-arm-gnueabihf": "4.62.4",+ "@rollup/rollup-linux-arm-musleabihf": "4.62.4",+ "@rollup/rollup-linux-arm64-gnu": "4.62.4",+ "@rollup/rollup-linux-arm64-musl": "4.62.4",+ "@rollup/rollup-linux-loong64-gnu": "4.62.4",+ "@rollup/rollup-linux-loong64-musl": "4.62.4",+ "@rollup/rollup-linux-ppc64-gnu": "4.62.4",+ "@rollup/rollup-linux-ppc64-musl": "4.62.4",+ "@rollup/rollup-linux-riscv64-gnu": "4.62.4",+ "@rollup/rollup-linux-riscv64-musl": "4.62.4",+ "@rollup/rollup-linux-s390x-gnu": "4.62.4",+ "@rollup/rollup-linux-x64-gnu": "4.62.4",+ "@rollup/rollup-linux-x64-musl": "4.62.4",+ "@rollup/rollup-openbsd-x64": "4.62.4",+ "@rollup/rollup-openharmony-arm64": "4.62.4",+ "@rollup/rollup-win32-arm64-msvc": "4.62.4",+ "@rollup/rollup-win32-ia32-msvc": "4.62.4",+ "@rollup/rollup-win32-x64-gnu": "4.62.4",+ "@rollup/rollup-win32-x64-msvc": "4.62.4",+ "fsevents": "~2.3.2"+ }+ },+ "node_modules/siginfo": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",+ "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",+ "dev": true,+ "license": "ISC"+ },+ "node_modules/source-map-js": {+ "version": "1.2.1",+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",+ "dev": true,+ "license": "BSD-3-Clause",+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/stackback": {+ "version": "0.0.2",+ "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",+ "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/std-env": {+ "version": "3.10.0",+ "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",+ "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/tinybench": {+ "version": "2.9.0",+ "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",+ "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/tinyexec": {+ "version": "0.3.2",+ "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",+ "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/tinypool": {+ "version": "1.1.1",+ "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",+ "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ }+ },+ "node_modules/tinyrainbow": {+ "version": "1.2.0",+ "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",+ "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/tinyspy": {+ "version": "3.0.2",+ "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",+ "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/vite": {+ "version": "5.4.21",+ "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",+ "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "esbuild": "^0.21.3",+ "postcss": "^8.4.43",+ "rollup": "^4.20.0"+ },+ "bin": {+ "vite": "bin/vite.js"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://github.com/vitejs/vite?sponsor=1"+ },+ "optionalDependencies": {+ "fsevents": "~2.3.3"+ },+ "peerDependencies": {+ "@types/node": "^18.0.0 || >=20.0.0",+ "less": "*",+ "lightningcss": "^1.21.0",+ "sass": "*",+ "sass-embedded": "*",+ "stylus": "*",+ "sugarss": "*",+ "terser": "^5.4.0"+ },+ "peerDependenciesMeta": {+ "@types/node": {+ "optional": true+ },+ "less": {+ "optional": true+ },+ "lightningcss": {+ "optional": true+ },+ "sass": {+ "optional": true+ },+ "sass-embedded": {+ "optional": true+ },+ "stylus": {+ "optional": true+ },+ "sugarss": {+ "optional": true+ },+ "terser": {+ "optional": true+ }+ }+ },+ "node_modules/vite-node": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.8.tgz",+ "integrity": "sha512-uPAwSr57kYjAUux+8E2j0q0Fxpn8M9VoyfGiRI8Kfktz9NcYMCenwY5RnZxnF1WTu3TGiYipirIzacLL3VVGFg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "cac": "^6.7.14",+ "debug": "^4.3.7",+ "es-module-lexer": "^1.5.4",+ "pathe": "^1.1.2",+ "vite": "^5.0.0"+ },+ "bin": {+ "vite-node": "vite-node.mjs"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/vitest": {+ "version": "2.1.8",+ "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.8.tgz",+ "integrity": "sha512-1vBKTZskHw/aosXqQUlVWWlGUxSJR8YtiyZDJAFeW2kPAeX6S3Sool0mjspO+kXLuxVWlEDDowBAeqeAQefqLQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/expect": "2.1.8",+ "@vitest/mocker": "2.1.8",+ "@vitest/pretty-format": "^2.1.8",+ "@vitest/runner": "2.1.8",+ "@vitest/snapshot": "2.1.8",+ "@vitest/spy": "2.1.8",+ "@vitest/utils": "2.1.8",+ "chai": "^5.1.2",+ "debug": "^4.3.7",+ "expect-type": "^1.1.0",+ "magic-string": "^0.30.12",+ "pathe": "^1.1.2",+ "std-env": "^3.8.0",+ "tinybench": "^2.9.0",+ "tinyexec": "^0.3.1",+ "tinypool": "^1.0.1",+ "tinyrainbow": "^1.2.0",+ "vite": "^5.0.0",+ "vite-node": "2.1.8",+ "why-is-node-running": "^2.3.0"+ },+ "bin": {+ "vitest": "vitest.mjs"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ },+ "peerDependencies": {+ "@edge-runtime/vm": "*",+ "@types/node": "^18.0.0 || >=20.0.0",+ "@vitest/browser": "2.1.8",+ "@vitest/ui": "2.1.8",+ "happy-dom": "*",+ "jsdom": "*"+ },+ "peerDependenciesMeta": {+ "@edge-runtime/vm": {+ "optional": true+ },+ "@types/node": {+ "optional": true+ },+ "@vitest/browser": {+ "optional": true+ },+ "@vitest/ui": {+ "optional": true+ },+ "happy-dom": {+ "optional": true+ },+ "jsdom": {+ "optional": true+ }+ }+ },+ "node_modules/why-is-node-running": {+ "version": "2.3.0",+ "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",+ "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "siginfo": "^2.0.0",+ "stackback": "0.0.2"+ },+ "bin": {+ "why-is-node-running": "cli.js"+ },+ "engines": {+ "node": ">=8"+ }}}}diff --git a/packages/crypto/package.json b/packages/crypto/package.jsonindex 95331e608..c86aafaa9 100644--- a/packages/crypto/package.json+++ b/packages/crypto/package.json@@ -20,12 +20,15 @@"scripts": {"build": "tsdown src/index.ts","prepublishOnly": "npm run build",- "watch": "npm run build -- --watch"+ "watch": "npm run build -- --watch",+ "test": "vitest run"},"dependencies": {"@notesnook/sodium": "file:../sodium"},- "devDependencies": {},+ "devDependencies": {+ "vitest": "2.1.8"+ },"repository": {"type": "git","url": "git+https://github.com/streetwriters/notesnook.git",diff --git a/packages/crypto/vitest.config.ts b/packages/crypto/vitest.config.tsnew file mode 100644index 000000000..6de291b67--- /dev/null+++ b/packages/crypto/vitest.config.ts@@ -0,0 +1,26 @@+/*+This file is part of the Notesnook project (https://notesnook.com/)++Copyright (C) 2023 Streetwriters (Private) Limited++This program is free software: you can redistribute it and/or modify+it under the terms of the GNU General Public License as published by+the Free Software Foundation, either version 3 of the License, or+(at your option) any later version.++This program is distributed in the hope that it will be useful,+but WITHOUT ANY WARRANTY; without even the implied warranty of+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+GNU General Public License for more details.++You should have received a copy of the GNU General Public License+along with this program. If not, see <http://www.gnu.org/licenses/>.+*/++import { defineConfig } from "vitest/config";++export default defineConfig({+ test: {+ include: ["__tests__/**/*.test.ts"]+ }+});