cojson 0.19.22 → 0.20.1

package/src/tests/sync.deleted.test.ts

@@ -0,0 +1,294 @@
+import { assert, beforeEach, describe, expect, test } from "vitest";
+import { expectMap } from "../coValue";
+import {
+  SyncMessagesLog,
+  TEST_NODE_CONFIG,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
+import { isDeleteSessionID, SessionID } from "../ids";
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+beforeEach(async () => {
+  // We want to simulate a real world communication that happens asynchronously
+  TEST_NODE_CONFIG.withAsyncPeers = true;
+
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("syncing deleted coValues", () => {
+  test("client loads a deleted coValue from server (tombstone-only)", async () => {
+    const { node: client } = setupTestNode({ connected: true });
+
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    // Delete on the server before the client loads.
+    map.core.deleteCoValue();
+    expect(map.core.isDeleted).toBe(true);
+
+    const mapOnClient = await loadCoValueOrFail(client, map.id);
+    const mapCoreOnClient = client.expectCoValueLoaded(map.id);
+
+    expect(mapCoreOnClient.isDeleted).toBe(true);
+    // Historical content should not be synced.
+    expect(mapOnClient.get("hello")).toBeUndefined();
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Group sessions: header/3",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("inbound filtering: after deletion, non-delete sessions in the same content message are ignored", async () => {
+    const client = setupTestNode({ connected: false });
+
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("k", "v", "trusting");
+
+    const contentBeforeDelete = map.core.newContentSince(undefined)?.[0];
+    assert(contentBeforeDelete);
+
+    // Create a delete marker on the server, but also keep a historical session around.
+    map.core.deleteCoValue();
+
+    const content = map.core.newContentSince(undefined)?.[0];
+    assert(content);
+
+    const groupContent = group.core.newContentSince(undefined)?.[0];
+    assert(groupContent);
+
+    // We merge the content before delete with the content after delete to simulate an older peer that might send extra sessions in the same message
+    Object.assign(contentBeforeDelete.new, content.new);
+
+    client.node.syncManager.handleNewContent(groupContent, "import");
+    client.node.syncManager.handleNewContent(content, "import");
+
+    const coreOnClient = client.node.expectCoValueLoaded(map.id);
+    expect(coreOnClient.isDeleted).toBe(true);
+
+    const contentOnClient = expectMap(coreOnClient.getCurrentContent());
+    expect(contentOnClient.get("k")).toBeUndefined();
+  });
+
+  test("should wait for the dependencies to be available before processing the deleted session/transaction", async () => {
+    const client = setupTestNode({ connected: false });
+
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+
+    // Create a delete marker on the server, but also keep a historical session around.
+    map.core.deleteCoValue();
+
+    const content = map.core.newContentSince(undefined)?.[0];
+    assert(content);
+
+    const groupContent = group.core.newContentSince(undefined)?.[0];
+    assert(groupContent);
+
+    client.node.syncManager.handleNewContent(content, "import");
+    client.node.syncManager.handleNewContent(groupContent, "import");
+
+    await waitFor(() => {
+      expect(client.node.expectCoValueLoaded(map.id).isDeleted).toBe(true);
+    });
+  });
+
+  test("outbound blocking: post-delete normal writes are ignored and do not produce content uploads", async () => {
+    const client = setupTestNode({ connected: true });
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    map.set("a", 1, "trusting");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    // Delete on the server and wait for it to propagate.
+    map.core.deleteCoValue();
+    await waitFor(() => {
+      expect(mapOnClient.core.isDeleted).toBe(true);
+    });
+
+    SyncMessagesLog.clear();
+
+    mapOnClient.set("x", "y", "trusting");
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Ensure we didn't produce outgoing content uploads as a result of the rejected write.
+    const messages = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(messages.some((m) => m.includes("CONTENT Map"))).toBe(false);
+  });
+
+  test("delete should be propagated to client-to-client sync", async () => {
+    const alice = setupTestNode();
+    alice.connectToSyncServer({
+      ourName: "alice",
+    });
+    const bob = setupTestNode();
+    bob.connectToSyncServer({
+      ourName: "bob",
+    });
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+    map.core.deleteCoValue();
+
+    await loadCoValueOrFail(bob.node, map.id);
+
+    await waitFor(() => {
+      expect(bob.node.expectCoValueLoaded(map.id).isDeleted).toBe(true);
+    });
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "bob -> server | LOAD Map sessions: empty",
+        "alice -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "alice -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> bob | KNOWN Map sessions: empty",
+        "server -> alice | KNOWN Group sessions: header/3",
+        "server -> alice | KNOWN Map sessions: header/1",
+        "server -> bob | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> bob | CONTENT Map header: true new: After: 0 New: 1",
+        "bob -> server | KNOWN Group sessions: header/3",
+        "bob -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("content synced after deletion should be ignored", async () => {
+    const alice = setupTestNode({ connected: true });
+    const bob = setupTestNode();
+
+    const { peerState: bobConnection } = bob.connectToSyncServer({
+      ourName: "bob",
+    });
+
+    const group = alice.node.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const mapOnBob = await loadCoValueOrFail(bob.node, map.id);
+
+    SyncMessagesLog.clear();
+
+    bobConnection.gracefulShutdown();
+
+    map.core.deleteCoValue();
+
+    await map.core.waitForSync();
+
+    mapOnBob.set("hello", "updated", "trusting");
+
+    bob.connectToSyncServer({
+      ourName: "bob",
+    });
+
+    await mapOnBob.core.waitForSync();
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/2",
+        "server -> bob | CONTENT Map header: false new: After: 0 New: 1",
+        "bob -> server | LOAD Group sessions: header/5",
+        "bob -> server | LOAD Map sessions: header/2",
+        "bob -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> bob | KNOWN Group sessions: header/5",
+        "server -> bob | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> bob | KNOWN Map sessions: header/3",
+        "bob -> server | KNOWN Map sessions: header/2",
+      ]
+    `);
+  });
+
+  test("should handle concurrent delete operations", async () => {
+    const alice = await setupTestAccount();
+    alice.connectToSyncServer({
+      ourName: "alice",
+    });
+    const bob = await setupTestAccount();
+    bob.connectToSyncServer({
+      ourName: "bob",
+    });
+
+    const group = jazzCloud.node.createGroup();
+    group.addMemberInternal(alice.account, "admin");
+    group.addMemberInternal(bob.account, "admin");
+
+    const map = group.createMap();
+    map.set("counter", 0, "trusting");
+    map.set("counter", 1, "trusting");
+
+    const mapOnAlice = await loadCoValueOrFail(alice.node, map.id);
+    const mapOnBob = await loadCoValueOrFail(bob.node, map.id);
+
+    SyncMessagesLog.clear();
+
+    mapOnAlice.core.deleteCoValue();
+    mapOnBob.core.deleteCoValue();
+
+    await mapOnAlice.core.waitForSync();
+    await mapOnBob.core.waitForSync();
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "alice -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "bob -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> alice | KNOWN Map sessions: header/3",
+        "server -> bob | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> bob | KNOWN Map sessions: header/4",
+        "server -> alice | CONTENT Map header: false new: After: 0 New: 1",
+        "bob -> server | KNOWN Map sessions: header/4",
+      ]
+    `);
+
+    expect(map.core.isDeleted).toBe(true);
+
+    const sessions = map.core.knownState().sessions;
+
+    expect(Object.keys(sessions)).toHaveLength(2);
+    expect(
+      Object.keys(sessions).every((sessionID) =>
+        isDeleteSessionID(sessionID as SessionID),
+      ),
+    ).toBe(true);
+  });
+});

package/src/tests/sync.mesh.test.ts

@@ -11,7 +11,8 @@ import {
   setupTestNode,
   waitFor,
 } from "./testUtils";
-import { stableStringify } from "../jsonStringify";
+import { Stringified } from "../jsonStringify";
+import { JsonValue } from "../jsonValue";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -325,7 +326,9 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
 
     msg.new[mesh.edgeFrance.node.currentSessionID]!.newTransactions.push({
       privacy: "trusting",
-      changes: stableStringify([{ op: "set", key: "hello", value: "updated" }]),
+      changes: JSON.stringify([
+        { op: "set", key: "hello", value: "updated" },
+      ]) as Stringified<JsonValue[]>,
       madeAt: Date.now(),
     });
 

package/src/tests/sync.storage.test.ts

@@ -8,6 +8,7 @@ import {
   vi,
 } from "vitest";
 
+import type { JsonValue } from "../exports";
 import { cojsonInternals, emptyKnownState } from "../exports";
 import {
   SyncMessagesLog,
@@ -19,7 +20,7 @@ import {
   tearDownTestMetricReader,
   waitFor,
 } from "./testUtils";
-import { stableStringify } from "../jsonStringify";
+import { Stringified } from "../jsonStringify";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -572,7 +573,9 @@ describe("client syncs with a server with storage", () => {
     const invalidMapContent = structuredClone(mapContent);
     invalidMapContent.new[bob.node.currentSessionID]!.newTransactions.push({
       privacy: "trusting",
-      changes: stableStringify([{ op: "set", key: "hello", value: "updated" }]),
+      changes: JSON.stringify([
+        { op: "set", key: "hello", value: "updated" },
+      ]) as Stringified<JsonValue[]>,
       madeAt: Date.now(),
     });
     client.node.syncManager.handleNewContent(invalidMapContent, "import");
@@ -1021,9 +1024,9 @@ describe("client syncs with a server with storage", () => {
           "server -> bob | CONTENT Map header: true new: After: 0 New: 1",
           "storage -> syncServer | CONTENT ParentGroup header: true new: After: 76 New: 73",
           "server -> bob | CONTENT ParentGroup header: false new: After: 76 New: 73 expectContentUntil: header/205",
-          "bob -> server | KNOWN ParentGroup sessions: header/76",
           "storage -> syncServer | CONTENT ParentGroup header: true new: After: 149 New: 56",
           "server -> bob | CONTENT ParentGroup header: false new: After: 149 New: 56",
+          "bob -> server | KNOWN ParentGroup sessions: header/76",
           "bob -> server | KNOWN Group sessions: header/5",
           "bob -> server | KNOWN Map sessions: header/1",
           "bob -> server | KNOWN ParentGroup sessions: header/149",

package/src/tests/sync.test.ts

@@ -18,7 +18,8 @@ import {
   tearDownTestMetricReader,
   waitFor,
 } from "./testUtils.js";
-import { stableStringify } from "../jsonStringify.js";
+import { Stringified } from "../jsonStringify.js";
+import { JsonValue } from "../jsonValue.js";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -168,7 +169,9 @@ test("should not verify transactions when SyncManager has verification disabled"
     [
       {
         privacy: "trusting",
-        changes: stableStringify([{ op: "set", key: "hello", value: "world" }]),
+        changes: JSON.stringify([
+          { op: "set", key: "hello", value: "world" },
+        ]) as Stringified<JsonValue[]>,
         madeAt: Date.now(),
       },
     ],

package/src/tests/testStorage.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import Database, { type Database as DatabaseT } from "libsql";
 import { onTestFinished } from "vitest";
-import { RawCoID, StorageAPI } from "../exports";
+import { RawCoID, SessionID, StorageAPI } from "../exports";
 import { SQLiteDatabaseDriver } from "../storage";
 import { getSqliteStorage } from "../storage/sqlite";
 import {
@@ -12,6 +12,7 @@ import {
   getSqliteStorageAsync,
 } from "../storage/sqliteAsync";
 import { SyncMessagesLog, SyncTestMessage } from "./testUtils";
+import { knownStateFromContent } from "../coValueContentMessage";
 
 class LibSQLSqliteAsyncDriver implements SQLiteDatabaseDriverAsync {
   private readonly db: DatabaseT;
@@ -131,12 +132,40 @@ export function createSyncStorage({
   return storage;
 }
 
+export async function getAllCoValuesWaitingForDelete(
+  storage: StorageAPI,
+): Promise<RawCoID[]> {
+  // @ts-expect-error - dbClient is private
+  return storage.dbClient.getAllCoValuesWaitingForDelete();
+}
+
+export async function getCoValueStoredSessions(
+  storage: StorageAPI,
+  id: RawCoID,
+): Promise<SessionID[]> {
+  return new Promise<SessionID[]>((resolve) => {
+    storage.load(
+      id,
+      (content) => {
+        if (content.id === id) {
+          resolve(
+            Object.keys(knownStateFromContent(content).sessions) as SessionID[],
+          );
+        }
+      },
+      () => {},
+    );
+  });
+}
+
 export function getDbPath(defaultDbPath?: string) {
   const dbPath = defaultDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
 
   if (!defaultDbPath) {
     onTestFinished(() => {
-      unlinkSync(dbPath);
+      setTimeout(() => {
+        unlinkSync(dbPath);
+      }, 100);
     });
   }
 

package/src/tests/testUtils.ts

@@ -5,7 +5,7 @@ import {
   MeterProvider,
   MetricReader,
 } from "@opentelemetry/sdk-metrics";
-import { expect, onTestFinished, vi } from "vitest";
+import { assert, expect, onTestFinished, vi } from "vitest";
 import { ControlledAccount, ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import {
@@ -28,15 +28,12 @@ import type { Peer, SyncMessage, SyncWhen } from "../sync.js";
 import { expectGroup } from "../typeUtils/expectGroup.js";
 import { toSimplifiedMessages } from "./messagesTestUtils.js";
 import { createAsyncStorage, createSyncStorage } from "./testStorage.js";
-import { PureJSCrypto } from "../crypto/PureJSCrypto.js";
 import { CoValueHeader } from "../coValueCore/verifiedState.js";
 import { idforHeader } from "../coValueCore/coValueCore.js";
 
 let Crypto = await WasmCrypto.create();
 
-export function setCurrentTestCryptoProvider(
-  crypto: WasmCrypto | PureJSCrypto,
-) {
+export function setCurrentTestCryptoProvider(crypto: WasmCrypto) {
   Crypto = crypto;
 }
 
@@ -271,6 +268,7 @@ export function blockMessageTypeOnOutgoingPeer(
   opts: {
     id?: string;
     once?: boolean;
+    matcher?: (msg: SyncMessage) => boolean;
   },
 ) {
   const push = peer.outgoing.push;
@@ -283,7 +281,8 @@ export function blockMessageTypeOnOutgoingPeer(
       typeof msg === "object" &&
       msg.action === messageType &&
       (!opts.id || msg.id === opts.id) &&
-      (!opts.once || !blockedIds.has(msg.id))
+      (!opts.once || !blockedIds.has(msg.id)) &&
+      (!opts.matcher || opts.matcher(msg))
     ) {
       blockedMessages.push(msg);
       blockedIds.add(msg.id);
@@ -503,11 +502,11 @@ export function setupTestNode(
   }
 
   async function addAsyncStorage(
-    opts: { ourName?: string; filename?: string } = {},
+    opts: { ourName?: string; filename?: string; storageName?: string } = {},
   ) {
     const storage = await createAsyncStorage({
       nodeName: opts.ourName ?? "client",
-      storageName: "storage",
+      storageName: opts.storageName ?? "storage",
       filename: opts.filename,
     });
     node.setStorage(storage);
@@ -640,10 +639,12 @@ export async function setupTestAccount(
     return { storage };
   }
 
-  async function addAsyncStorage(opts: { ourName?: string } = {}) {
+  async function addAsyncStorage(
+    opts: { ourName?: string; storageName?: string } = {},
+  ) {
     const storage = await createAsyncStorage({
       nodeName: opts.ourName ?? "client",
-      storageName: "storage",
+      storageName: opts.storageName ?? "storage",
     });
     ctx.node.setStorage(storage);
 
@@ -658,9 +659,14 @@ export async function setupTestAccount(
     await ctx.node.gracefulShutdown();
   });
 
+  const account = ctx.node
+    .getCoValue(ctx.accountID)
+    .getCurrentContent() as RawAccount;
+
   return {
     node: ctx.node,
     accountID: ctx.accountID,
+    account,
     connectToSyncServer,
     addStorage,
     addAsyncStorage,
@@ -814,6 +820,21 @@ export function fillCoMapWithLargeData(map: RawCoMap) {
   return map;
 }
 
+export function importContentIntoNode(
+  coValue: CoValueCore,
+  node: LocalNode,
+  chunks?: number,
+) {
+  const content = coValue.newContentSince(undefined);
+  assert(content);
+  for (const [i, chunk] of content.entries()) {
+    if (chunks && i >= chunks) {
+      break;
+    }
+    node.syncManager.handleNewContent(chunk, "import");
+  }
+}
+
 // ============================================================================
 // MessageChannel Test Helpers
 // ============================================================================

package/dist/crypto/PureJSCrypto.d.ts

@@ -1,77 +0,0 @@
-import { PrivateTransaction, Transaction, TrustingTransaction } from "../coValueCore/verifiedState.js";
-import { RawCoID, SessionID, TransactionID } from "../ids.js";
-import { Stringified } from "../jsonStringify.js";
-import { JsonObject, JsonValue } from "../jsonValue.js";
-import { CryptoProvider, Encrypted, KeyID, KeySecret, Sealed, SealerID, SealerSecret, SessionLogImpl, Signature, SignerID, SignerSecret } from "./crypto.js";
-import { ControlledAccountOrAgent } from "../coValues/account.js";
-export type Blake3State = {
-    update: (buf: Uint8Array) => Blake3State;
-    digest: () => Uint8Array;
-    clone: () => Blake3State;
-};
-/**
- * Pure JavaScript implementation of the CryptoProvider interface using noble-curves and noble-ciphers libraries.
- * This provides a fallback implementation that doesn't require WebAssembly, offering:
- * - Signing/verifying (Ed25519)
- * - Encryption/decryption (XSalsa20)
- * - Sealing/unsealing (X25519 + XSalsa20-Poly1305)
- * - Hashing (BLAKE3)
- */
-export declare class PureJSCrypto extends CryptoProvider<Blake3State> {
-    static create(): Promise<PureJSCrypto>;
-    createStreamingHash(): Blake3State;
-    blake3HashOnce(data: Uint8Array): Uint8Array;
-    blake3HashOnceWithContext(data: Uint8Array, { context }: {
-        context: Uint8Array;
-    }): Uint8Array;
-    generateNonce(input: Uint8Array): Uint8Array;
-    generateJsonNonce(material: JsonValue): Uint8Array;
-    newEd25519SigningKey(): Uint8Array;
-    getSignerID(secret: SignerSecret): SignerID;
-    sign(secret: SignerSecret, message: JsonValue): Signature;
-    verify(signature: Signature, message: JsonValue, id: SignerID): boolean;
-    newX25519StaticSecret(): Uint8Array;
-    getSealerID(secret: SealerSecret): SealerID;
-    encrypt<T extends JsonValue, N extends JsonValue>(value: T, keySecret: KeySecret, nOnceMaterial: N): Encrypted<T, N>;
-    decryptRaw<T extends JsonValue, N extends JsonValue>(encrypted: Encrypted<T, N>, keySecret: KeySecret, nOnceMaterial: N): Stringified<T>;
-    seal<T extends JsonValue>({ message, from, to, nOnceMaterial, }: {
-        message: T;
-        from: SealerSecret;
-        to: SealerID;
-        nOnceMaterial: {
-            in: RawCoID;
-            tx: TransactionID;
-        };
-    }): Sealed<T>;
-    unseal<T extends JsonValue>(sealed: Sealed<T>, sealer: SealerSecret, from: SealerID, nOnceMaterial: {
-        in: RawCoID;
-        tx: TransactionID;
-    }): T | undefined;
-    createSessionLog(coID: RawCoID, sessionID: SessionID, signerID?: SignerID): SessionLogImpl;
-}
-export declare class PureJSSessionLog implements SessionLogImpl {
-    private readonly coID;
-    private readonly sessionID;
-    private readonly signerID;
-    private readonly crypto;
-    transactions: string[];
-    lastSignature: Signature | undefined;
-    streamingHash: Blake3State;
-    constructor(coID: RawCoID, sessionID: SessionID, signerID: SignerID | undefined, crypto: PureJSCrypto);
-    clone(): SessionLogImpl;
-    tryAdd(transactions: Transaction[], newSignature: Signature, skipVerify: boolean): void;
-    internalTryAdd(transactions: string[], newSignature: Signature, skipVerify: boolean): `signature_z${string}`;
-    internalAddNewTransaction(transaction: string, signerAgent: ControlledAccountOrAgent): `signature_z${string}`;
-    addNewPrivateTransaction(signerAgent: ControlledAccountOrAgent, changes: JsonValue[], keyID: KeyID, keySecret: KeySecret, madeAt: number, meta: JsonObject | undefined): {
-        signature: Signature;
-        transaction: PrivateTransaction;
-    };
-    addNewTrustingTransaction(signerAgent: ControlledAccountOrAgent, changes: JsonValue[], madeAt: number, meta: JsonObject | undefined): {
-        signature: Signature;
-        transaction: TrustingTransaction;
-    };
-    decryptNextTransactionChangesJson(txIndex: number, keySecret: KeySecret): string;
-    decryptNextTransactionMetaJson(txIndex: number, keySecret: KeySecret): string | undefined;
-    free(): void;
-}
-//# sourceMappingURL=PureJSCrypto.d.ts.map

package/dist/crypto/PureJSCrypto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PureJSCrypto.d.ts","sourceRoot":"","sources":["../../src/crypto/PureJSCrypto.ts"],"names":[],"mappings":"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"}