@neelegirl/baileys 1.5.2 → 1.5.3

package/lib/Signal/WASignalGroup/ciphertext-message.d.ts

@@ -0,0 +1,9 @@
+export declare class CiphertextMessage {
+    readonly UNSUPPORTED_VERSION: number
+    readonly CURRENT_VERSION: number
+    readonly WHISPER_TYPE: number
+    readonly PREKEY_TYPE: number
+    readonly SENDERKEY_TYPE: number
+    readonly SENDERKEY_DISTRIBUTION_TYPE: number
+    readonly ENCRYPTED_MESSAGE_OVERHEAD: number
+}

package/lib/Signal/WASignalGroup/ciphertext-message.js

@@ -0,0 +1,19 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1
+        this.CURRENT_VERSION = 3
+        this.WHISPER_TYPE = 2
+        this.PREKEY_TYPE = 3
+        this.SENDERKEY_TYPE = 4
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53
+    }
+}
+
+module.exports = {
+  CiphertextMessage
+}

package/lib/Signal/WASignalGroup/ciphertext_message.js

@@ -1,16 +1,16 @@
-class CiphertextMessage {
-    UNSUPPORTED_VERSION = 1;
-
-    CURRENT_VERSION = 3;
-
-    WHISPER_TYPE = 2;
-
-    PREKEY_TYPE = 3;
-
-    SENDERKEY_TYPE = 4;
-
-    SENDERKEY_DISTRIBUTION_TYPE = 5;
-
-    ENCRYPTED_MESSAGE_OVERHEAD = 53;
-}
+class CiphertextMessage {
+    UNSUPPORTED_VERSION = 1;
+
+    CURRENT_VERSION = 3;
+
+    WHISPER_TYPE = 2;
+
+    PREKEY_TYPE = 3;
+
+    SENDERKEY_TYPE = 4;
+
+    SENDERKEY_DISTRIBUTION_TYPE = 5;
+
+    ENCRYPTED_MESSAGE_OVERHEAD = 53;
+}
 module.exports = CiphertextMessage;

package/lib/Signal/WASignalGroup/group-session-builder.d.ts

@@ -0,0 +1,17 @@
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message'
+import { SenderKeyName } from './sender-key-name'
+import { SenderKeyRecord } from './sender-key-record'
+
+interface SenderKeyStore {
+    loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>
+    storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>
+}
+
+export declare class GroupSessionBuilder {
+    private readonly senderKeyStore
+    constructor(senderKeyStore: SenderKeyStore)
+    process(senderKeyName: SenderKeyName, senderKeyDistributionMessage: SenderKeyDistributionMessage): Promise<void>
+    create(senderKeyName: SenderKeyName): Promise<SenderKeyDistributionMessage>
+}
+
+export {}

package/lib/Signal/WASignalGroup/group-session-builder.js

@@ -0,0 +1,72 @@
+"use strict"
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v })
+}) : function(o, v) {
+    o["default"] = v
+})
+
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = []
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+            return ar
+        }
+        return ownKeys(o)
+    }
+    return function (mod) {
+        if (mod && mod.__esModule) return mod
+        var result = {}
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
+        __setModuleDefault(result, mod)
+        return result
+    }
+})()
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const keyhelper = __importStar(require("./keyhelper"))
+const sender_key_distribution_message_1 = require("./sender-key-distribution-message")
+
+class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName)
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey())
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord)
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName)
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId()
+            const senderKey = keyhelper.generateSenderKey()
+            const signingKey = keyhelper.generateSenderSigningKey()
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey)
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord)
+        }
+        const state = senderKeyRecord.getSenderKeyState()
+        if (!state) {
+            throw new Error('No session state available')
+        }
+        return new sender_key_distribution_message_1.SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic())
+    }
+}
+
+module.exports = {
+  GroupSessionBuilder
+}

package/lib/Signal/WASignalGroup/group.proto

@@ -1,42 +1,42 @@
-package groupproto;
-
-message SenderKeyMessage {
-	optional uint32 id         = 1;
-	optional uint32 iteration  = 2;
-	optional bytes  ciphertext = 3;
-  }
-  
-  message SenderKeyDistributionMessage {
-	optional uint32 id         = 1;
-	optional uint32 iteration  = 2;
-	optional bytes  chainKey   = 3;
-	optional bytes  signingKey = 4;
-  }
-  
-  message SenderChainKey {
-    optional uint32 iteration = 1;
-    optional bytes  seed      = 2;
-}
-
-message SenderMessageKey {
-    optional uint32 iteration = 1;
-    optional bytes  seed      = 2;
-}
-
-message SenderSigningKey {
-    optional bytes public  = 1;
-    optional bytes private = 2;
-}
-
-message SenderKeyStateStructure {
-    
-
-    optional uint32           senderKeyId       = 1;
-    optional SenderChainKey   senderChainKey    = 2;
-    optional SenderSigningKey senderSigningKey  = 3;
-    repeated SenderMessageKey senderMessageKeys = 4;
-}
-
-message SenderKeyRecordStructure {
-    repeated SenderKeyStateStructure senderKeyStates = 1;
+package groupproto;
+
+message SenderKeyMessage {
+	optional uint32 id         = 1;
+	optional uint32 iteration  = 2;
+	optional bytes  ciphertext = 3;
+  }
+  
+  message SenderKeyDistributionMessage {
+	optional uint32 id         = 1;
+	optional uint32 iteration  = 2;
+	optional bytes  chainKey   = 3;
+	optional bytes  signingKey = 4;
+  }
+  
+  message SenderChainKey {
+    optional uint32 iteration = 1;
+    optional bytes  seed      = 2;
+}
+
+message SenderMessageKey {
+    optional uint32 iteration = 1;
+    optional bytes  seed      = 2;
+}
+
+message SenderSigningKey {
+    optional bytes public  = 1;
+    optional bytes private = 2;
+}
+
+message SenderKeyStateStructure {
+    
+
+    optional uint32           senderKeyId       = 1;
+    optional SenderChainKey   senderChainKey    = 2;
+    optional SenderSigningKey senderSigningKey  = 3;
+    repeated SenderMessageKey senderMessageKeys = 4;
+}
+
+message SenderKeyRecordStructure {
+    repeated SenderKeyStateStructure senderKeyStates = 1;
 }

package/lib/Signal/WASignalGroup/group_cipher.d.ts

@@ -0,0 +1,19 @@
+import { SenderKeyName } from './sender-key-name'
+import { SenderKeyRecord } from './sender-key-record'
+
+export interface SenderKeyStore {
+    loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>
+    storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>
+}
+
+export declare class GroupCipher {
+    private readonly senderKeyStore
+    private readonly senderKeyName
+    constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName)
+    private queueJob
+    encrypt(paddedPlaintext: Uint8Array | string): Promise<Uint8Array>
+    decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array>
+    private getSenderKey
+    private getPlainText
+    private getCipherText
+}

package/lib/Signal/WASignalGroup/group_cipher.js

@@ -1,120 +1,111 @@
-const queue_job = require('./queue_job');
-const SenderKeyMessage = require('./sender_key_message');
-const crypto = require('@neelegirl/libsignal/src/crypto');
+"use strict"
 
-class GroupCipher {
-  constructor(senderKeyStore, senderKeyName) {
-    this.senderKeyStore = senderKeyStore;
-    this.senderKeyName = senderKeyName;
-  }
-
-  queueJob(awaitable) {
-    return queue_job(this.senderKeyName.toString(), awaitable)
-  }
-
-  async encrypt(paddedPlaintext) {
-    return await this.queueJob(async () => {
-      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-      if (!record) {
-        throw new Error("No SenderKeyRecord found for encryption")
-      }
-      const senderKeyState = record.getSenderKeyState();
-      if (!senderKeyState) {
-        throw new Error("No session to encrypt message");
-      }
-      const iteration = senderKeyState.getSenderChainKey().getIteration()
-      const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1)
-
-      const ciphertext = await this.getCipherText(
-        senderKey.getIv(),
-        senderKey.getCipherKey(),
-        paddedPlaintext
-      );
-
-      const senderKeyMessage = new SenderKeyMessage(
-        senderKeyState.getKeyId(),
-        senderKey.getIteration(),
-        ciphertext,
-        senderKeyState.getSigningKeyPrivate()
-      );
-      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-      return senderKeyMessage.serialize()
-    })
-  }
-
-  async decrypt(senderKeyMessageBytes) {
-    return await this.queueJob(async () => {
-      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-      if (!record) {
-        throw new Error("No SenderKeyRecord found for decryption")
-      }
-      const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-      const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-      if (!senderKeyState) {
-        throw new Error("No session found to decrypt message")
-      }
-
-      senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
-      const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
-      // senderKeyState.senderKeyStateStructure.senderSigningKey.private =
-
-      const plaintext = await this.getPlainText(
-        senderKey.getIv(),
-        senderKey.getCipherKey(),
-        senderKeyMessage.getCipherText()
-      );
+Object.defineProperty(exports, "__esModule", { value: true })
 
-      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+const crypto_1 = require("@neelegirl/libsignal/src/crypto")
+const sender_key_message_1 = require("./sender-key-message")
 
-      return plaintext;
-    })
-  }
-
-  getSenderKey(senderKeyState, iteration) {
-    let senderChainKey = senderKeyState.getSenderChainKey();
-    if (senderChainKey.getIteration() > iteration) {
-      if (senderKeyState.hasSenderMessageKey(iteration)) {
-        return senderKeyState.removeSenderMessageKey(iteration);
-      }
-      throw new Error(
-        `Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`
-      );
+class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore
+        this.senderKeyName = senderKeyName
     }
-
-    if (iteration - senderChainKey.getIteration() > 2000) {
-      throw new Error('Over 2000 messages into the future!');
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+        
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for encryption')
+        }
+        
+        const senderKeyState = record.getSenderKeyState()
+        
+        if (!senderKeyState) {
+            throw new Error('No session to encrypt message')
+        }
+        
+        const iteration = senderKeyState.getSenderChainKey().getIteration()
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1)
+        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext)
+        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate())
+        
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record)
+        
+        return senderKeyMessage.serialize()
     }
-
-    while (senderChainKey.getIteration() < iteration) {
-      senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
-      senderChainKey = senderChainKey.getNext();
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+        
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for decryption')
+        }
+        
+        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes)
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId())
+        
+        if (!senderKeyState) {
+            throw new Error('No session found to decrypt message');
+        }
+        
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic())
+        
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration())
+        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText())
+        
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record)
+        
+        return plaintext
     }
-
-    senderKeyState.setSenderChainKey(senderChainKey.getNext());
-    return senderChainKey.getSenderMessageKey();
-  }
-
-  getPlainText(iv, key, ciphertext) {
-    try {
-      const plaintext = crypto.decrypt(key, ciphertext, iv);
-      return plaintext;
-    } catch (e) {
-      //console.log(e.stack);
-      throw new Error('InvalidMessageException');
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey()
+        
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration)
+                
+                if (!messageKey) {
+                    throw new Error('No sender message key found for iteration')
+                }
+                
+                return messageKey
+            }
+            
+            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`)
+        }
+        
+        if (iteration - senderChainKey.getIteration() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey())
+            senderChainKey = senderChainKey.getNext()
+        }
+        
+        senderKeyState.setSenderChainKey(senderChainKey.getNext())
+        
+        return senderChainKey.getSenderMessageKey()
     }
-  }
-
-  getCipherText(iv, key, plaintext) {
-    try {
-      iv = typeof iv === 'string' ? Buffer.from(iv, 'base64') : iv;
-      key = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
-      const crypted = crypto.encrypt(key, Buffer.from(plaintext), iv);
-      return crypted;
-    } catch (e) {
-      //console.log(e.stack);
-      throw new Error('InvalidMessageException');
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return crypto_1.decrypt(key, ciphertext, iv)
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException')
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            const ivBuffer = typeof iv === 'string' ? Buffer.from(iv, 'base64') : iv
+            const keyBuffer = typeof key === 'string' ? Buffer.from(key, 'base64') : key
+            const plaintextBuffer = typeof plaintext === 'string' ? Buffer.from(plaintext) : plaintext
+            return crypto_1.encrypt(keyBuffer, plaintextBuffer, ivBuffer)
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException')
+        }
     }
-  }
 }
 
-module.exports = GroupCipher;
+module.exports = {
+  GroupCipher
+}

package/lib/Signal/WASignalGroup/group_session_builder.js

@@ -1,46 +1,46 @@
-//const utils = require('../../common/utils');
-const SenderKeyDistributionMessage = require('./sender_key_distribution_message');
-
-const keyhelper = require("./keyhelper");
-class GroupSessionBuilder {
-  constructor(senderKeyStore) {
-    this.senderKeyStore = senderKeyStore;
-  }
-
-  async process(senderKeyName, senderKeyDistributionMessage) {
-    //console.log('GroupSessionBuilder process', senderKeyName, senderKeyDistributionMessage);
-    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
-    senderKeyRecord.addSenderKeyState(
-      senderKeyDistributionMessage.getId(),
-      senderKeyDistributionMessage.getIteration(),
-      senderKeyDistributionMessage.getChainKey(),
-      senderKeyDistributionMessage.getSignatureKey()
-    );
-    await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
-  }
-
-  // [{"senderKeyId":1742199468,"senderChainKey":{"iteration":0,"seed":"yxMY9VFQcXEP34olRAcGCtsgx1XoKsHfDIh+1ea4HAQ="},"senderSigningKey":{"public":""}}]
-  async create(senderKeyName) {
-    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
-    //console.log('GroupSessionBuilder create session', senderKeyName, senderKeyRecord);
-
-    if (senderKeyRecord.isEmpty()) {
-      const keyId = keyhelper.generateSenderKeyId();
-      const senderKey = keyhelper.generateSenderKey();
-      const signingKey = keyhelper.generateSenderSigningKey();
-
-      senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
-      await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
-    }
-
-    const state = senderKeyRecord.getSenderKeyState();
-
-    return new SenderKeyDistributionMessage(
-      state.getKeyId(),
-      state.getSenderChainKey().getIteration(),
-      state.getSenderChainKey().getSeed(),
-      state.getSigningKeyPublic()
-    );
-  }
-}
+//const utils = require('../../common/utils');
+const SenderKeyDistributionMessage = require('./sender_key_distribution_message');
+
+const keyhelper = require("./keyhelper");
+class GroupSessionBuilder {
+  constructor(senderKeyStore) {
+    this.senderKeyStore = senderKeyStore;
+  }
+
+  async process(senderKeyName, senderKeyDistributionMessage) {
+    //console.log('GroupSessionBuilder process', senderKeyName, senderKeyDistributionMessage);
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    senderKeyRecord.addSenderKeyState(
+      senderKeyDistributionMessage.getId(),
+      senderKeyDistributionMessage.getIteration(),
+      senderKeyDistributionMessage.getChainKey(),
+      senderKeyDistributionMessage.getSignatureKey()
+    );
+    await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+  }
+
+  // [{"senderKeyId":1742199468,"senderChainKey":{"iteration":0,"seed":"yxMY9VFQcXEP34olRAcGCtsgx1XoKsHfDIh+1ea4HAQ="},"senderSigningKey":{"public":""}}]
+  async create(senderKeyName) {
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    //console.log('GroupSessionBuilder create session', senderKeyName, senderKeyRecord);
+
+    if (senderKeyRecord.isEmpty()) {
+      const keyId = keyhelper.generateSenderKeyId();
+      const senderKey = keyhelper.generateSenderKey();
+      const signingKey = keyhelper.generateSenderSigningKey();
+
+      senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+      await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+
+    const state = senderKeyRecord.getSenderKeyState();
+
+    return new SenderKeyDistributionMessage(
+      state.getKeyId(),
+      state.getSenderChainKey().getIteration(),
+      state.getSenderChainKey().getSeed(),
+      state.getSigningKeyPublic()
+    );
+  }
+}
 module.exports = GroupSessionBuilder;

package/lib/Signal/WASignalGroup/index.d.ts

@@ -0,0 +1,11 @@
+export { GroupSessionBuilder } from './group-session-builder'
+export { SenderKeyDistributionMessage } from './sender-key-distribution-message'
+export { SenderKeyRecord } from './sender-key-record'
+export { SenderKeyName } from './sender-key-name'
+export { GroupCipher } from './group_cipher'
+export { SenderKeyState } from './sender-key-state'
+export { SenderKeyMessage } from './sender-key-message'
+export { SenderMessageKey } from './sender-message-key'
+export { SenderChainKey } from './sender-chain-key'
+export { CiphertextMessage } from './ciphertext-message'
+export * as keyhelper from './keyhelper'

package/lib/Signal/WASignalGroup/index.js

@@ -1,6 +1,61 @@
-module.exports.GroupSessionBuilder = require('./group_session_builder')
-module.exports.SenderKeyDistributionMessage = require('./sender_key_distribution_message')
-module.exports.SenderKeyRecord = require('./sender_key_record')
-module.exports.SenderKeyName = require('./sender_key_name')
-module.exports.GroupCipher = require('./group_cipher')
-// signal fixed
+"use strict"
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v })
+}) : function(o, v) {
+    o["default"] = v
+})
+
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = []
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+            return ar
+        }
+        return ownKeys(o)
+    }
+    return function (mod) {
+        if (mod && mod.__esModule) return mod
+        var result = {}
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
+        __setModuleDefault(result, mod)
+        return result
+    }
+})()
+
+Object.defineProperty(exports, "__esModule", { value: true })
+exports.keyhelper = exports.CiphertextMessage = exports.SenderChainKey = exports.SenderMessageKey = exports.SenderKeyMessage = exports.SenderKeyState = exports.GroupCipher = exports.SenderKeyName = exports.SenderKeyRecord = exports.SenderKeyDistributionMessage = exports.GroupSessionBuilder = void 0
+var group_session_builder_1 = require("./group-session-builder")
+Object.defineProperty(exports, "GroupSessionBuilder", { enumerable: true, get: function () { return group_session_builder_1.GroupSessionBuilder } })
+var sender_key_distribution_message_1 = require("./sender-key-distribution-message")
+Object.defineProperty(exports, "SenderKeyDistributionMessage", { enumerable: true, get: function () { return sender_key_distribution_message_1.SenderKeyDistributionMessage } })
+var sender_key_record_1 = require("./sender-key-record")
+Object.defineProperty(exports, "SenderKeyRecord", { enumerable: true, get: function () { return sender_key_record_1.SenderKeyRecord } })
+var sender_key_name_1 = require("./sender-key-name")
+Object.defineProperty(exports, "SenderKeyName", { enumerable: true, get: function () { return sender_key_name_1.SenderKeyName } })
+var group_cipher_1 = require("./group_cipher")
+Object.defineProperty(exports, "GroupCipher", { enumerable: true, get: function () { return group_cipher_1.GroupCipher } })
+var sender_key_state_1 = require("./sender-key-state")
+Object.defineProperty(exports, "SenderKeyState", { enumerable: true, get: function () { return sender_key_state_1.SenderKeyState } })
+var sender_key_message_1 = require("./sender-key-message")
+Object.defineProperty(exports, "SenderKeyMessage", { enumerable: true, get: function () { return sender_key_message_1.SenderKeyMessage } })
+var sender_message_key_1 = require("./sender-message-key")
+Object.defineProperty(exports, "SenderMessageKey", { enumerable: true, get: function () { return sender_message_key_1.SenderMessageKey } })
+var sender_chain_key_1 = require("./sender-chain-key")
+Object.defineProperty(exports, "SenderChainKey", { enumerable: true, get: function () { return sender_chain_key_1.SenderChainKey } })
+var ciphertext_message_1 = require("./ciphertext-message")
+Object.defineProperty(exports, "CiphertextMessage", { enumerable: true, get: function () { return ciphertext_message_1.CiphertextMessage } })
+exports.keyhelper = __importStar(require("./keyhelper"))