vialeys 0.0.1 → 0.0.2

package/lib/Utils/signal.js

@@ -2,16 +2,27 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const lodash_1 = require("lodash")
-const Defaults_1 = require("../Defaults")
-const WABinary_1 = require("../WABinary")
-const crypto_1 = require("./crypto")
-const generics_1 = require("./generics")
+const { chunk } = require("lodash")
+const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
+const {
+  S_WHATSAPP_NET, 
+  getBinaryNodeChild, 
+  getBinaryNodeChildren, 
+  getBinaryNodeChildUInt, 
+  getBinaryNodeChildBuffer,
+  assertNodeErrorFree, 
+  jidDecode
+} = require("../WABinary")
+const { 
+  Curve,
+  generateSignalPubKey 
+} = require("./crypto")
+const { encodeBigEndian } = require("./generics")
 
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
-        identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+        identifierKey: generateSignalPubKey(accountSignatureKey)
     }
 }
 
@@ -30,7 +41,7 @@ const generateOrGetPreKeys = (creds, range) => {
     const newPreKeys = {}
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+            newPreKeys[i] = Curve.generateKeyPair()
         }
     }
     return {
@@ -44,7 +55,7 @@ const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
@@ -54,20 +65,20 @@ const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(id, 3) },
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 })
 
 const parseAndInjectE2ESessions = async (node, repository) => {
     const extractKey = (key) => (key ? ({
-        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
-        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
+        keyId: getBinaryNodeChildUInt(key, 'id', 3),
+        publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+        signature: getBinaryNodeChildBuffer(key, 'signature')
     }) : undefined)
-    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user')
     for (const node of nodes) {
-        WABinary_1.assertNodeErrorFree(node)
+        assertNodeErrorFree(node)
     }
     // Most of the work in repository.injectE2ESession is CPU intensive, not IO
     // So Promise.all doesn't really help here,
@@ -75,19 +86,19 @@ const parseAndInjectE2ESessions = async (node, repository) => {
     // This way we chunk it in smaller parts and between those parts we can yield to the event loop
     // It's rare case when you need to E2E sessions for so many users, but it's possible
     const chunkSize = 100
-    const chunks = lodash_1.chunk(nodes, chunkSize)
+    const chunks = chunk(nodes, chunkSize)
     for (const nodesChunk of chunks) {
         await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
-            const key = WABinary_1.getBinaryNodeChild(node, 'key')
-            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
+            const signedKey = getBinaryNodeChild(node, 'skey')
+            const key = getBinaryNodeChild(node, 'key')
+            const identity = getBinaryNodeChildBuffer(node, 'identity')
             const jid = node.attrs.jid
-            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4)
             await repository.injectE2ESession({
                 jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: crypto_1.generateSignalPubKey(identity),
+                    identityKey: generateSignalPubKey(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
@@ -97,11 +108,11 @@ const parseAndInjectE2ESessions = async (node, repository) => {
 }
 
 const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+    const { user: myUser, device: myDevice } = jidDecode(myJid)
     const extracted = []
     for (const userResult of result) {
         const { devices, id } = userResult
-        const { user } = WABinary_1.jidDecode(id)
+        const { user } = jidDecode(id)
         const deviceList = devices?.deviceList
         if (Array.isArray(deviceList)) {
             for (const { id: device, keyIndex } of deviceList) {
@@ -140,11 +151,11 @@ const getNextPreKeysNode = async (state, count) => {
         attrs: {
             xmlns: 'encrypt',
             type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
         },
         content: [
-            { tag: 'registration', attrs: {}, content: generics_1.encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
             { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
             { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
             xmppSignedPreKey(creds.signedPreKey)

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,17 +1,13 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const async_mutex_1 = __importDefault(require("async-mutex"))
-const promises_1 = require("fs/promises")
-const path_1 = require("path")
-const WAProto_1 = require("../../WAProto")
-const auth_utils_1 = require("./auth-utils")
-const generics_1 = require("./generics")
+const { Mutex } = require("async-mutex")
+const { promises } = require("fs")
+const { join } = require("path")
+const { proto } = require("../../WAProto")
+const { initAuthCreds } = require("./auth-utils")
+const { BufferJSON } = require("./generics")
 // We need to lock files due to the fact that we are using async functions to read and write files
 // https://github.com/WhiskeySockets/Baileys/issues/794
 // https://github.com/nodejs/node/issues/26338
@@ -22,7 +18,7 @@ const fileLocks = new Map()
 const getFileLock = (path) => {
 	let mutex = fileLocks.get(path)
 	if (!mutex) {
-		mutex = new async_mutex_1.Mutex() 
+		mutex = new Mutex() 
 		fileLocks.set(path, mutex)
 	}
 
@@ -39,11 +35,11 @@ const getFileLock = (path) => {
 const useMultiFileAuthState = async (folder) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
-        const filePath = path_1.join(folder, fixFileName(file))
+        const filePath = join(folder, fixFileName(file))
         const mutex = getFileLock(filePath)
         return mutex.acquire().then(async (release) => {
             try {
-               await promises_1.writeFile(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
+               await promises.writeFile(filePath, JSON.stringify(data, BufferJSON.replacer))
             } finally {
                 release()
             }
@@ -51,47 +47,47 @@ const useMultiFileAuthState = async (folder) => {
     }
     const readData = async (file) => {
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
+            const filePath = join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             const data = await mutex.acquire().then(async (release) => {
                 try {
-                    return await promises_1.readFile(filePath, { encoding: 'utf-8' })
+                    return await promises.readFile(filePath, { encoding: 'utf-8' })
                 } finally {
                     release()
                 }
             })
 
-            return JSON.parse(data, generics_1.BufferJSON.reviver)
+            return JSON.parse(data, BufferJSON.reviver)
         } catch (error) {
             return null
         }
     }
     const removeData = async (file) => {
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
+            const filePath = join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             await mutex.acquire().then(async (release) => {
                try {
-                    await promises_1.unlink(filePath)
+                    await promises.unlink(filePath)
                 } finally {
                     release()
                 }
             })
         } catch {}
     }
-    const folderInfo = await promises_1.stat(folder).catch(() => { })
+    const folderInfo = await promises.stat(folder).catch(() => { })
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`)
         }
     }
     else {
-        await promises_1.mkdir(folder, { recursive: true })
+        await promises.mkdir(folder, { recursive: true })
     }
     const fixFileName = (file) => { 
         return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
     }
-    const creds = await readData('creds.json') || auth_utils_1.initAuthCreds()
+    const creds = await readData('creds.json') || initAuthCreds()
     return {
         state: {
             creds,
@@ -101,7 +97,7 @@ const useMultiFileAuthState = async (folder) => {
                     await Promise.all(ids.map(async (id) => {
                         let value = await readData(`${type}-${id}.json`)
                         if (type === 'app-state-sync-key' && value) {
-                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value)
                         }
                         data[id] = value
                     }))

package/lib/Utils/validate-connection.js

@@ -2,14 +2,21 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const boom_1 = require("@hapi/boom")
-const crypto_1 = require("crypto")
-const WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const WABinary_1 = require("../WABinary")
-const crypto_2 = require("./crypto")
-const generics_1 = require("./generics")
-const signal_1 = require("./signal")
+const { Boom } = require("@hapi/boom")
+const { createHash } = require("crypto")
+const { proto } = require("../../WAProto")
+const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
+const {
+  jidDecode, 
+  getBinaryNodeChild,
+  S_WHATSAPP_NET
+} = require("../WABinary")
+const {
+  Curve, 
+  hmacSign 
+} = require("./crypto")
+const { encodeBigEndian } = require("./generics")
+const { createSignalIdentity } = require("./signal")
 
 const getUserAgent = (config) => {
     return {
@@ -18,8 +25,8 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2],
         },
-        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
         osBuildNumber: '0.1',
@@ -31,13 +38,13 @@ const getUserAgent = (config) => {
 }
 
 const PLATFORM_MAP = {
-    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32, 
-    'Android': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN32, 
+    'Android': proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
 }
 
 const getWebInfo = (config) => {
-    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
     if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
         webSubPlatform = PLATFORM_MAP[config.browser[0]]
     }
@@ -46,8 +53,8 @@ const getWebInfo = (config) => {
 
 const getClientPayload = (config) => {
     const payload = {
-        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     }
     payload.webInfo = getWebInfo(config)
@@ -55,7 +62,7 @@ const getClientPayload = (config) => {
 }
 
 const generateLoginNode = (userJid, config) => {
-    const { user, device } = WABinary_1.jidDecode(userJid)
+    const { user, device } = jidDecode(userJid)
     const payload = {
         ...getClientPayload(config),
         passive: false,
@@ -63,18 +70,18 @@ const generateLoginNode = (userJid, config) => {
         username: +user,
         device: device,
     }
-    return WAProto_1.proto.ClientPayload.fromObject(payload)
+    return proto.ClientPayload.fromObject(payload)
 }
 
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase()
-    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.DESKTOP
+    return proto.DeviceProps.PlatformType[platformType] || proto.DeviceProps.PlatformType.DESKTOP
 }
 
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
     // the app version needs to be md5 hashed
     // and passed in
-    const appVersionBuf = crypto_1.createHash('md5')
+    const appVersionBuf = createHash('md5')
         .update(config.version.join('.')) // join as string
         .digest()
 
@@ -106,7 +113,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         }
     }
 
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+    const companionProto = proto.DeviceProps.encode(companion).finish()
 
     const registerPayload = {
         ...getClientPayload(config),
@@ -115,55 +122,55 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: generics_1.encodeBigEndian(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: generics_1.encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
         }
     }
 
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload)
+    return proto.ClientPayload.fromObject(registerPayload)
 }
 
 const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
     const msgId = stanza.attrs.id
-    const pairSuccessNode = WABinary_1.getBinaryNodeChild(stanza, 'pair-success')
-    const deviceIdentityNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device-identity')
-    const platformNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'platform')
-    const deviceNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device')
-    const businessNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'biz')
+    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success')
+    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity')
+    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform')
+    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device')
+    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz')
     if (!deviceIdentityNode || !deviceNode) {
-        throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza })
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza })
     }
     const bizName = businessNode?.attrs?.name
     const jid = deviceNode.attrs.jid
     const lid = deviceNode.attrs.lid
-    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
     
     let hmacPrefix = Buffer.from([])
-    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
         hmacPrefix = Buffer.from([6, 5])
     }
 
-    const advSign = crypto_2.hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'))
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'))
     if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new boom_1.Boom('Invalid account signature')
+        throw new Boom('Invalid account signature')
     }
 
-    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details)
+    const account = proto.ADVSignedDeviceIdentity.decode(details)
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account
 
-    const decodedDeviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails)
+    const decodedDeviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails)
 
     const accountSignaturePrefix =
-        decodedDeviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED
+        decodedDeviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
             ? Buffer.from([6, 5])
             : Buffer.from([6, 0])
     const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public])
-    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new boom_1.Boom('Failed to verify account signature')
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature')
     }
 
     const deviceMsg = Buffer.concat([
@@ -172,14 +179,14 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
         signedIdentityKey.public,
         accountSignatureKey
     ])
-    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
-    const identity = signal_1.createSignalIdentity(lid, accountSignatureKey)
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg)
+    const identity = createSignalIdentity(lid, accountSignatureKey)
     const accountEnc = encodeSignedDeviceIdentity(account, false)
-    const deviceIdentityData = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
+    const deviceIdentityData = proto.ADVDeviceIdentity.decode(account.details)
     const reply = {
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
             type: 'result',
             id: msgId,
         },
@@ -219,7 +226,7 @@ const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     if (!includeSignatureKey || !account.accountSignatureKey?.length) {
         account.accountSignatureKey = null
     }
-    return WAProto_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
+    return proto.ADVSignedDeviceIdentity.encode(account).finish()
 }
 
 module.exports = {

package/lib/WABinary/decode.js

@@ -1,38 +1,12 @@
 "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 (mod) {
-    if (mod && mod.__esModule) return mod
-    var result = {}
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-    __setModuleDefault(result, mod)
-    return result
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const util_1 = require("util")
-const zlib_1 = require("zlib")
-const constants = __importStar(require("./constants"))
-const jid_utils_1 = require("./jid-utils")
-const inflatePromise = util_1.promisify(zlib_1.inflate)
+const { promisify } = require("util")
+const { inflate } = require("zlib")
+const { jidEncode } = require("./jid-utils")
+const constants = require("./constants")
+const inflatePromise = promisify(inflate)
 
 const decompressingIfRequired = async (buffer) => {
     if (2 & buffer.readUInt8()) {
@@ -168,7 +142,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         const agent = readByte()
         const device = readByte()
         const user = readString(readByte())
-        return jid_utils_1.jidEncode(user, agent === 0 ? 's.whatsapp.net' : 'lid', device)
+        return jidEncode(user, agent === 0 ? 's.whatsapp.net' : 'lid', device)
     }
     
     const readString = (tag) => {

package/lib/WABinary/encode.js

@@ -1,35 +1,9 @@
 "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 (mod) {
-    if (mod && mod.__esModule) return mod
-    var result = {}
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-    __setModuleDefault(result, mod)
-    return result
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const constants = __importStar(require("./constants"))
-const jid_utils_1 = require("./jid-utils")
+const { jidDecode } = require("./jid-utils")
+const constants = require("./constants")
 
 const encodeBinaryNode = (node, opts = constants, buffer = [0]) => {
     const encoded = encodeBinaryNodeInner(node, opts, buffer)
@@ -201,7 +175,7 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
             writePackedBytes(str, 'hex')
         }
         else if (str) {
-            const decodedJid = (0, jid_utils_1.jidDecode)(str)
+            const decodedJid = jidDecode(str)
             if (decodedJid) {
                 writeJid(decodedJid)
             }

package/lib/WABinary/generic-utils.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const boom_1 = require("@hapi/boom")
-const WAProto_1 = require("../../WAProto")
+const { Boom } = require("@hapi/boom")
+const { proto } = require("../../WAProto")
 
 // some extra useful utilities
 const getBinaryNodeChildren = (node, childTag) => {
@@ -53,7 +53,7 @@ const getBinaryNodeChildUInt = (node, childTag, length) => {
 const assertNodeErrorFree = (node) => {
     const errNode = getBinaryNodeChild(node, 'error')
     if (errNode) {
-        throw new boom_1.Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code })
+        throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code })
     }
 }
 
@@ -71,7 +71,7 @@ const getBinaryNodeMessages = ({ content }) => {
     if (Array.isArray(content)) {
         for (const item of content) {
             if (item.tag === 'message') {
-                msgs.push(WAProto_1.proto.WebMessageInfo.decode(item.content))
+                msgs.push(proto.WebMessageInfo.decode(item.content))
             }
         }
     }

package/lib/WABinary/index.js

@@ -1,22 +1,38 @@
 "use strict"
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+const __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
+
+    let desc = Object.getOwnPropertyDescriptor(m, k)
+
     if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
+      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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+    Object.defineProperty(o, k2, desc) 
+
+    }) : (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k
+        o[k2] = m[k]
+    }
+))
+
+const __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) {
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
+            __createBinding(exports, m, p)
+       }
+   }
 }
 
-Object.defineProperty(exports, "__esModule", { value: true })
+Object.defineProperty(exports, "__esModule", { 
+    value: true 
+})
 
 __exportStar(require("./encode"), exports)
 __exportStar(require("./decode"), exports)