@zervonex/baileys 3.0.2 → 3.0.4

package/WAProto/parser.js

@@ -1,313 +1,334 @@
-import { createRequire } from 'module'
-import { writeFileSync, renameSync } from 'fs'
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import logger from '../lib/Utils/logger.js'
-
-const require = createRequire(import.meta.url)
-const acorn = require('acorn')
-const walk = require('acorn-walk')
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const addPrefix = (lines, prefix) => lines.map(l => prefix + l)
-
-function extractAllExpressions(node) {
-    const out = [node]
-    const exp = node.expression
-    if (exp) out.push(exp)
-    if (node?.expression?.arguments?.length)
-        for (const arg of node.expression.arguments)
-            if (arg?.body?.body?.length)
-                for (const e of arg.body.body) out.push(...extractAllExpressions(e))
-    if (node?.body?.body?.length)
-        for (const e of node.body.body)
-            if (e.expression) out.push(...extractAllExpressions(e.expression))
-    if (node.expression?.expressions?.length)
-        for (const e of node.expression.expressions) out.push(...extractAllExpressions(e))
-    return out
-}
-
-function getNumericEnumValue(node) {
-    if (node?.type === 'Literal' && typeof node.value === 'number') return node.value
-    if (node?.type === 'UnaryExpression' && (node.operator === '-' || node.operator === '+') &&
-        node.argument?.type === 'Literal' && typeof node.argument.value === 'number')
-        return node.operator === '-' ? -node.argument.value : node.argument.value
-    return undefined
-}
-
-function parseBundleSources(sources) {
-    const nodes = []
-    const opts = { ecmaVersion: 'latest', allowHashBang: true }
-    for (let i = 0; i < sources.length; i++) {
-        const patched = sources[i].replaceAll('LimitSharing$Trigger', 'LimitSharing$TriggerType')
-        sources[i] = null
-        try { nodes.push(...acorn.parse(patched, { ...opts, sourceType: 'script' }).body) }
-        catch {
-            try { nodes.push(...acorn.parse(patched, { ...opts, sourceType: 'module' }).body) }
-            catch (e) { logger.warn(`[WAProto] Skipping bundle ${i + 1}: ${e.message}`) }
-        }
-    }
-    return nodes
-}
-
-function filterProtoModules(allNodes) {
-    return allNodes.filter(m => extractAllExpressions(m).find(e => e?.left?.property?.name === 'internalSpec'))
-}
-
-export function extractSchema(bundleSources) {
-    const allNodes = parseBundleSources(Array.isArray(bundleSources) ? bundleSources : [bundleSources])
-    const modules = filterProtoModules(allNodes)
-
-    const unspecName = n => n.endsWith('Spec') ? n.slice(0, -4) : n
-    const getNesting = n => n.split('$').slice(0, -1).join('$')
-    const rename = n => unspecName(n)
-
-    const modulesInfo = {}
-    const moduleIndentationMap = {}
-
-    modules.forEach(module => {
-        const modName = module?.expression?.arguments?.[0]?.value ?? `__anon_${Math.random()}`
-        modulesInfo[modName] = { crossRefs: [] }
-        walk.simple(module, {
-            AssignmentExpression(node) {
-                if (node?.right?.type === 'CallExpression' &&
-                    node?.right?.arguments?.length === 1 &&
-                    node?.right?.arguments[0]?.type !== 'ObjectExpression')
-                    modulesInfo[modName].crossRefs.push({ alias: node.left?.name, module: node.right.arguments[0].value })
-            },
-        })
-    })
-
-    for (const mod of modules) {
-        const modName = mod?.expression?.arguments?.[0]?.value
-        const modInfo = modulesInfo[modName]
-        const assignments = []
-
-        walk.simple(mod, {
-            AssignmentExpression(node) {
-                const left = node.left
-                if (left?.property?.name &&
-                    left.property.name !== 'internalSpec' &&
-                    left.property.name !== 'internalDefaults' &&
-                    left.property.name !== 'name') assignments.push(left)
-            },
-        })
-
-        const makeBlankIdent = a => {
-            const key = rename(a?.property?.name)
-            const indentation = getNesting(key)
-            moduleIndentationMap[key] = moduleIndentationMap[key] || {}
-            moduleIndentationMap[key].indentation = indentation
-            if (indentation.length) {
-                moduleIndentationMap[indentation] = moduleIndentationMap[indentation] || {}
-                moduleIndentationMap[indentation].members = moduleIndentationMap[indentation].members || new Set()
-                moduleIndentationMap[indentation].members.add(key)
-            }
-            return [key, { name: key }]
-        }
-
-        modInfo.identifiers = Object.fromEntries(assignments.map(makeBlankIdent).reverse())
-
-        const enumAliases = {}
-        walk.ancestor(mod, {
-            Property(node, anc) {
-                const fatherNode = anc[anc.length - 3]
-                const fatherFather = anc[anc.length - 4]
-                if (fatherNode?.type === 'AssignmentExpression' &&
-                    fatherNode?.left?.property?.name === 'internalSpec' &&
-                    fatherNode?.right?.properties?.length) {
-                    const values = fatherNode.right.properties.map(p => ({ name: p.key.name, id: p.value.value }))
-                    enumAliases[fatherNode?.left?.name] = values
-                } else if (fatherNode?.type === 'VariableDeclarator' &&
-                    fatherNode?.init?.type === 'ObjectExpression' &&
-                    fatherNode.init.properties.length &&
-                    fatherNode.init.properties.every(p => getNumericEnumValue(p.value) !== undefined)) {
-                    const values = fatherNode.init.properties.map(p => ({ name: p.key.name || p.key.value, id: getNumericEnumValue(p.value) }))
-                    enumAliases[fatherNode.id?.name] = values
-                } else if (node?.key?.name && fatherNode?.arguments?.length > 0) {
-                    const values = fatherNode.arguments?.[0]?.properties?.map(p => ({ name: p.key.name, id: p.value.value }))
-                    const nameAlias = fatherFather?.left?.name || fatherFather?.id?.name
-                    if (nameAlias) enumAliases[nameAlias] = values
-                }
-            },
-        })
-
-        walk.simple(mod, {
-            AssignmentExpression(node) {
-                if (node.left?.type === 'MemberExpression' && modInfo.identifiers?.[rename(node.left.property?.name)]) {
-                    const ident = modInfo.identifiers[rename(node.left.property.name)]
-                    ident.alias = node.right?.name
-                    ident.enumValues = enumAliases[ident.alias]
-                }
-            },
-        })
-    }
-
-    const findByAlias = (identifiers, alias) => Object.values(identifiers).find(item => item.alias === alias)
-
-    for (const mod of modules) {
-        const modName = mod?.expression?.arguments?.[0]?.value
-        const modInfo = modulesInfo[modName]
-
-        walk.simple(mod, {
-            AssignmentExpression(node) {
-                if (node.left?.type !== 'MemberExpression' ||
-                    node.left.property?.name !== 'internalSpec' ||
-                    node.right?.type !== 'ObjectExpression') return
-
-                const targetIdent = Object.values(modInfo.identifiers).find(v => v.alias === node.left.object?.name)
-                if (!targetIdent) return
-
-                const constraints = [], rawMembers = []
-                for (const p of node.right.properties) {
-                    p.key.name = p.key.type === 'Identifier' ? p.key.name : p.key.value
-                        ; (p.key.name.substring(0, 2) === '__' ? constraints : rawMembers).push(p)
-                }
-
-                let members = rawMembers.map(({ key: { name }, value: { elements } }) => {
-                    let type
-                    const flags = []
-                    const unwrapBinaryOr = n =>
-                        n.type === 'BinaryExpression' && n.operator === '|'
-                            ? [].concat(unwrapBinaryOr(n.left), unwrapBinaryOr(n.right))
-                            : [n]
-
-                    unwrapBinaryOr(elements[1]).forEach(m => {
-                        if (m.type !== 'MemberExpression' || m.object?.type !== 'MemberExpression') return
-                        if (m.object.property?.name === 'TYPES') {
-                            type = m.property.name.toLowerCase()
-                            if (type === 'map' && elements[2]?.type === 'ArrayExpression') {
-                                let typeStr = 'map<'
-                                elements[2].elements.forEach((el, i) => {
-                                    typeStr += el?.property?.name ? el.property.name.toLowerCase()
-                                        : (findByAlias(modInfo.identifiers, el.name)?.name ?? el.name)
-                                    if (i < elements[2].elements.length - 1) typeStr += ', '
-                                })
-                                type = typeStr + '>'
-                            }
-                        } else if (m.object.property?.name === 'FLAGS') {
-                            flags.push(m.property.name.toLowerCase())
-                        }
-                    })
-
-                    if (type === 'message' || type === 'enum') {
-                        if (elements[2]?.type === 'Identifier') {
-                            const found = Object.values(modInfo.identifiers).find(v => v.alias === elements[2].name)
-                            type = found?.name
-                        } else if (elements[2]?.type === 'MemberExpression') {
-                            const targetAlias = elements[2]?.object?.name || elements[2]?.object?.left?.name || elements[2]?.object?.callee?.name
-                            const crossRef = modInfo.crossRefs.find(r => r.alias === targetAlias)
-                            if (elements[1]?.property?.name === 'ENUM' && elements[2]?.property?.name?.includes('Type'))
-                                type = rename(elements[2].property.name)
-                            else if (elements[2]?.property?.name?.includes('Spec'))
-                                type = rename(elements[2].property.name)
-                            else if (crossRef && crossRef.module !== '$InternalEnum' && modulesInfo[crossRef.module]?.identifiers?.[rename(elements[2].property.name)])
-                                type = rename(elements[2].property.name)
-                        }
-                    }
-
-                    return { name, id: elements[0].value, type, flags }
-                })
-
-                constraints.forEach(c => {
-                    if (c.key.name === '__oneofs__' && c.value.type === 'ObjectExpression') {
-                        const oneofs = c.value.properties.map(p => ({
-                            name: p.key.name, type: '__oneof__',
-                            members: p.value.elements.map(e => {
-                                const idx = members.findIndex(m => m.name === e.value)
-                                const member = members[idx]
-                                members.splice(idx, 1)
-                                return member
-                            }),
-                        }))
-                        members.push(...oneofs)
-                    }
-                })
-
-                targetIdent.members = members
-            },
-        })
-    }
-
-    return { modulesInfo, moduleIndentationMap }
-}
-
-export function generateProto3(modulesInfo, moduleIndentationMap, version) {
-    const indent = '  '
-    const unnest = n => n.split('$').slice(-1)[0]
-
-    const stringifyMember = (info, completeFlags, parentName) => {
-        if (info.type === '__oneof__')
-            return [`oneof ${info.name} {`, ...addPrefix([].concat(...info.members.map(m => stringifyMember(m, false))), indent), '}']
-        if (info.flags.includes('packed')) { info.flags.splice(info.flags.indexOf('packed'), 1); info.packed = ' [packed=true]' }
-        const reqIdx = info.flags.indexOf('required'); if (reqIdx !== -1) info.flags[reqIdx] = 'optional'
-        if (completeFlags && !info.flags.length && info.type && !info.type.includes('map')) info.flags.push('optional')
-        const indentation = moduleIndentationMap[info.type]?.indentation
-        let typeName = unnest(info.type || 'bytes')
-        if (indentation !== parentName && indentation) typeName = `${indentation.replaceAll('$', '.')}.${typeName}`
-        return [`${info.flags.join(' ')}${info.flags.length ? ' ' : ''}${typeName} ${info.name} = ${info.id}${info.packed || ''};`]
-    }
-
-    const decodedProtoMap = {}
-
-    for (const [, modInfo] of Object.entries(modulesInfo)) {
-        if (!modInfo.identifiers) continue
-
-        const stringifyEnum = (ident, overrideName = null) => [
-            `enum ${overrideName || ident.displayName || ident.name} {`,
-            ...addPrefix(ident.enumValues.map(v => `${v.name} = ${v.id};`), indent),
-            '}',
-        ]
-
-        function stringifyMessage(ident) {
-            const nestedKeys = moduleIndentationMap[ident.name]?.members
-            const result = [
-                `message ${ident.displayName || ident.name} {`,
-                ...addPrefix([].concat(...ident.members.map(m => stringifyMember(m, true, ident.name))), indent),
-            ]
-            if (nestedKeys?.size) {
-                for (const memberName of Array.from(nestedKeys).sort()) {
-                    let entity = modInfo.identifiers[memberName]
-                    if (entity) {
-                        entity = { ...entity, displayName: entity.name.slice(ident.name.length + 1) }
-                        result.push(...addPrefix(getEntity(entity), indent))
-                    }
-                }
-            }
-            result.push('}', '')
-            return result
-        }
-
-        const getEntity = v => {
-            if (v.members) return stringifyMessage(v)
-            if (v.enumValues?.length) return stringifyEnum(v)
-            return [`// Unknown entity ${v.name}`]
-        }
-
-        for (const v of Object.values(modInfo.identifiers))
-            if (!moduleIndentationMap[v.name]?.indentation?.length)
-                decodedProtoMap[v.name] = getEntity(v).join('\n')
-    }
-
-    const body = Object.keys(decodedProtoMap).sort().map(k => decodedProtoMap[k]).join('\n')
-    return `syntax = "proto3";\npackage proto;\n${version ? `\n/// WhatsApp Version: ${version}\n` : ''}\n${body}`
-}
-
-export function parseBundle(bundle, version) {
-    const sources = Array.isArray(bundle) ? bundle : [bundle]
-    const { modulesInfo, moduleIndentationMap } = extractSchema(sources)
-    return generateProto3(modulesInfo, moduleIndentationMap, version)
-}
-
-export async function parseAndWriteProto(bundle, version, outPath = PROTO_FILE) {
-    const protoText = parseBundle(bundle, version)
-    const tmp = outPath + '.tmp'
-    writeFileSync(tmp, protoText, 'utf8')
-    renameSync(tmp, outPath)
-    const unknown = [...protoText.matchAll(/\/\/ Unknown entity (.+)/g)].map(m => m[1])
-    if (unknown.length) logger.warn(`[WAProto] ${unknown.length} unknown entities: ${unknown.join(', ')}`)
-    return {
-        messageCount: Object.values(modulesInfo).reduce((s, m) => s + Object.keys(m.identifiers || {}).length, 0),
-        unknownCount: unknown.length,
-    }
+import { createRequire } from 'module'
+import { writeFileSync, renameSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import logger from '../lib/Utils/logger.js'
+
+const require = createRequire(import.meta.url)
+const acorn = require('acorn')
+const walk = require('acorn-walk')
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const addPrefix = (lines, prefix) => lines.map(l => prefix + l)
+
+function extractAllExpressions(node) {
+    const out = [node]
+    const exp = node.expression
+    if (exp) out.push(exp)
+    if (node?.expression?.arguments?.length)
+        for (const arg of node.expression.arguments)
+            if (arg?.body?.body?.length)
+                for (const e of arg.body.body) out.push(...extractAllExpressions(e))
+    if (node?.body?.body?.length)
+        for (const e of node.body.body)
+            if (e.expression) out.push(...extractAllExpressions(e.expression))
+    if (node.expression?.expressions?.length)
+        for (const e of node.expression.expressions) out.push(...extractAllExpressions(e))
+    return out
+}
+
+function getNumericEnumValue(node) {
+    if (node?.type === 'Literal' && typeof node.value === 'number') return node.value
+    if (node?.type === 'UnaryExpression' && (node.operator === '-' || node.operator === '+') &&
+        node.argument?.type === 'Literal' && typeof node.argument.value === 'number')
+        return node.operator === '-' ? -node.argument.value : node.argument.value
+    return undefined
+}
+
+function parseBundleSources(sources) {
+    const nodes = []
+    const opts = { ecmaVersion: 'latest', allowHashBang: true }
+    for (let i = 0; i < sources.length; i++) {
+        const patched = sources[i].replaceAll('LimitSharing$Trigger', 'LimitSharing$TriggerType')
+        sources[i] = null
+        try { nodes.push(...acorn.parse(patched, { ...opts, sourceType: 'script' }).body) }
+        catch {
+            try { nodes.push(...acorn.parse(patched, { ...opts, sourceType: 'module' }).body) }
+            catch (e) { logger.warn(`[WAProto] Skipping bundle ${i + 1}: ${e.message}`) }
+        }
+    }
+    return nodes
+}
+
+function extractProtoSources(bundle) {
+    const out = [], targets = new Set(['"$InternalEnum"', '"WAProtoConst"'])
+    let i = 0
+    while (i < bundle.length) {
+        const start = bundle.indexOf('__d(', i)
+        if (start === -1) break
+        const ns = bundle.indexOf('"', start + 4)
+        const name = bundle.slice(ns, bundle.indexOf('"', ns + 1) + 1)
+        if (targets.has(name) || name.endsWith('.pb"')) {
+            let depth = 0, j = start
+            while (j < bundle.length) {
+                if (bundle[j] === '(') depth++
+                else if (bundle[j] === ')' && --depth === 0) { out.push(bundle.slice(start, j + 1)); break }
+                j++
+            }
+            i = j + 1
+        } else i = start + 4
+    }
+    return out.length ? out : [bundle]
+}
+
+function filterProtoModules(allNodes) {
+    return allNodes.filter(m => extractAllExpressions(m).find(e => e?.left?.property?.name === 'internalSpec'))
+}
+
+export function extractSchema(bundleSources) {
+    const allNodes = parseBundleSources(extractProtoSources(Array.isArray(bundleSources) ? bundleSources.join('') : bundleSources))
+    const modules = filterProtoModules(allNodes)
+
+    const unspecName = n => n.endsWith('Spec') ? n.slice(0, -4) : n
+    const getNesting = n => n.split('$').slice(0, -1).join('$')
+    const rename = n => unspecName(n)
+
+    const modulesInfo = {}
+    const moduleIndentationMap = {}
+
+    modules.forEach(module => {
+        const modName = module?.expression?.arguments?.[0]?.value ?? `__anon_${Math.random()}`
+        modulesInfo[modName] = { crossRefs: [] }
+        walk.simple(module, {
+            AssignmentExpression(node) {
+                if (node?.right?.type === 'CallExpression' &&
+                    node?.right?.arguments?.length === 1 &&
+                    node?.right?.arguments[0]?.type !== 'ObjectExpression')
+                    modulesInfo[modName].crossRefs.push({ alias: node.left?.name, module: node.right.arguments[0].value })
+            },
+        })
+    })
+
+    for (const mod of modules) {
+        const modName = mod?.expression?.arguments?.[0]?.value
+        const modInfo = modulesInfo[modName]
+        const assignments = []
+
+        walk.simple(mod, {
+            AssignmentExpression(node) {
+                const left = node.left
+                if (left?.property?.name &&
+                    left.property.name !== 'internalSpec' &&
+                    left.property.name !== 'internalDefaults' &&
+                    left.property.name !== 'name') assignments.push(left)
+            },
+        })
+
+        const makeBlankIdent = a => {
+            const key = rename(a?.property?.name)
+            const indentation = getNesting(key)
+            moduleIndentationMap[key] = moduleIndentationMap[key] || {}
+            moduleIndentationMap[key].indentation = indentation
+            if (indentation.length) {
+                moduleIndentationMap[indentation] = moduleIndentationMap[indentation] || {}
+                moduleIndentationMap[indentation].members = moduleIndentationMap[indentation].members || new Set()
+                moduleIndentationMap[indentation].members.add(key)
+            }
+            return [key, { name: key }]
+        }
+
+        modInfo.identifiers = Object.fromEntries(assignments.map(makeBlankIdent).reverse())
+
+        const enumAliases = {}
+        walk.ancestor(mod, {
+            Property(node, anc) {
+                const fatherNode = anc[anc.length - 3]
+                const fatherFather = anc[anc.length - 4]
+                if (fatherNode?.type === 'AssignmentExpression' &&
+                    fatherNode?.left?.property?.name === 'internalSpec' &&
+                    fatherNode?.right?.properties?.length) {
+                    const values = fatherNode.right.properties.map(p => ({ name: p.key.name, id: p.value.value }))
+                    enumAliases[fatherNode?.left?.name] = values
+                } else if (fatherNode?.type === 'VariableDeclarator' &&
+                    fatherNode?.init?.type === 'ObjectExpression' &&
+                    fatherNode.init.properties.length &&
+                    fatherNode.init.properties.every(p => getNumericEnumValue(p.value) !== undefined)) {
+                    const values = fatherNode.init.properties.map(p => ({ name: p.key.name || p.key.value, id: getNumericEnumValue(p.value) }))
+                    enumAliases[fatherNode.id?.name] = values
+                } else if (node?.key?.name && fatherNode?.arguments?.length > 0) {
+                    const values = fatherNode.arguments?.[0]?.properties?.map(p => ({ name: p.key.name, id: p.value.value }))
+                    const nameAlias = fatherFather?.left?.name || fatherFather?.id?.name
+                    if (nameAlias) enumAliases[nameAlias] = values
+                }
+            },
+        })
+
+        walk.simple(mod, {
+            AssignmentExpression(node) {
+                if (node.left?.type === 'MemberExpression' && modInfo.identifiers?.[rename(node.left.property?.name)]) {
+                    const ident = modInfo.identifiers[rename(node.left.property.name)]
+                    ident.alias = node.right?.name
+                    ident.enumValues = enumAliases[ident.alias]
+                }
+            },
+        })
+    }
+
+    const findByAlias = (identifiers, alias) => Object.values(identifiers).find(item => item.alias === alias)
+
+    for (const mod of modules) {
+        const modName = mod?.expression?.arguments?.[0]?.value
+        const modInfo = modulesInfo[modName]
+
+        walk.simple(mod, {
+            AssignmentExpression(node) {
+                if (node.left?.type !== 'MemberExpression' ||
+                    node.left.property?.name !== 'internalSpec' ||
+                    node.right?.type !== 'ObjectExpression') return
+
+                const targetIdent = Object.values(modInfo.identifiers).find(v => v.alias === node.left.object?.name)
+                if (!targetIdent) return
+
+                const constraints = [], rawMembers = []
+                for (const p of node.right.properties) {
+                    p.key.name = p.key.type === 'Identifier' ? p.key.name : p.key.value
+                        ; (p.key.name.substring(0, 2) === '__' ? constraints : rawMembers).push(p)
+                }
+
+                let members = rawMembers.map(({ key: { name }, value: { elements } }) => {
+                    let type
+                    const flags = []
+                    const unwrapBinaryOr = n =>
+                        n.type === 'BinaryExpression' && n.operator === '|'
+                            ? [].concat(unwrapBinaryOr(n.left), unwrapBinaryOr(n.right))
+                            : [n]
+
+                    unwrapBinaryOr(elements[1]).forEach(m => {
+                        if (m.type !== 'MemberExpression' || m.object?.type !== 'MemberExpression') return
+                        if (m.object.property?.name === 'TYPES') {
+                            type = m.property.name.toLowerCase()
+                            if (type === 'map' && elements[2]?.type === 'ArrayExpression') {
+                                let typeStr = 'map<'
+                                elements[2].elements.forEach((el, i) => {
+                                    typeStr += el?.property?.name ? el.property.name.toLowerCase()
+                                        : (findByAlias(modInfo.identifiers, el.name)?.name ?? el.name)
+                                    if (i < elements[2].elements.length - 1) typeStr += ', '
+                                })
+                                type = typeStr + '>'
+                            }
+                        } else if (m.object.property?.name === 'FLAGS') {
+                            flags.push(m.property.name.toLowerCase())
+                        }
+                    })
+
+                    if (type === 'message' || type === 'enum') {
+                        if (elements[2]?.type === 'Identifier') {
+                            const found = Object.values(modInfo.identifiers).find(v => v.alias === elements[2].name)
+                            type = found?.name
+                        } else if (elements[2]?.type === 'MemberExpression') {
+                            const targetAlias = elements[2]?.object?.name || elements[2]?.object?.left?.name || elements[2]?.object?.callee?.name
+                            const crossRef = modInfo.crossRefs.find(r => r.alias === targetAlias)
+                            if (elements[1]?.property?.name === 'ENUM' && elements[2]?.property?.name?.includes('Type'))
+                                type = rename(elements[2].property.name)
+                            else if (elements[2]?.property?.name?.includes('Spec'))
+                                type = rename(elements[2].property.name)
+                            else if (crossRef && crossRef.module !== '$InternalEnum' && modulesInfo[crossRef.module]?.identifiers?.[rename(elements[2].property.name)])
+                                type = rename(elements[2].property.name)
+                        }
+                    }
+
+                    return { name, id: elements[0].value, type, flags }
+                })
+
+                constraints.forEach(c => {
+                    if (c.key.name === '__oneofs__' && c.value.type === 'ObjectExpression') {
+                        const oneofs = c.value.properties.map(p => ({
+                            name: p.key.name, type: '__oneof__',
+                            members: p.value.elements.map(e => {
+                                const idx = members.findIndex(m => m.name === e.value)
+                                const member = members[idx]
+                                members.splice(idx, 1)
+                                return member
+                            }),
+                        }))
+                        members.push(...oneofs)
+                    }
+                })
+
+                targetIdent.members = members
+            },
+        })
+    }
+
+    return { modulesInfo, moduleIndentationMap }
+}
+
+export function generateProto3(modulesInfo, moduleIndentationMap, version) {
+    const indent = '  '
+    const unnest = n => n.split('$').slice(-1)[0]
+
+    const stringifyMember = (info, completeFlags, parentName) => {
+        if (info.type === '__oneof__')
+            return [`oneof ${info.name} {`, ...addPrefix([].concat(...info.members.map(m => stringifyMember(m, false))), indent), '}']
+        if (info.flags.includes('packed')) { info.flags.splice(info.flags.indexOf('packed'), 1); info.packed = ' [packed=true]' }
+        const reqIdx = info.flags.indexOf('required'); if (reqIdx !== -1) info.flags[reqIdx] = 'optional'
+        if (completeFlags && !info.flags.length && info.type && !info.type.includes('map')) info.flags.push('optional')
+        const indentation = moduleIndentationMap[info.type]?.indentation
+        let typeName = unnest(info.type || 'bytes')
+        if (indentation !== parentName && indentation) typeName = `${indentation.replaceAll('$', '.')}.${typeName}`
+        return [`${info.flags.join(' ')}${info.flags.length ? ' ' : ''}${typeName} ${info.name} = ${info.id}${info.packed || ''};`]
+    }
+
+    const decodedProtoMap = {}
+
+    for (const [, modInfo] of Object.entries(modulesInfo)) {
+        if (!modInfo.identifiers) continue
+
+        const stringifyEnum = (ident, overrideName = null) => [
+            `enum ${overrideName || ident.displayName || ident.name} {`,
+            ...addPrefix(ident.enumValues.map(v => `${v.name} = ${v.id};`), indent),
+            '}',
+        ]
+
+        function stringifyMessage(ident) {
+            const nestedKeys = moduleIndentationMap[ident.name]?.members
+            const result = [
+                `message ${ident.displayName || ident.name} {`,
+                ...addPrefix([].concat(...ident.members.map(m => stringifyMember(m, true, ident.name))), indent),
+            ]
+            if (nestedKeys?.size) {
+                for (const memberName of Array.from(nestedKeys).sort()) {
+                    let entity = modInfo.identifiers[memberName]
+                    if (entity) {
+                        entity = { ...entity, displayName: entity.name.slice(ident.name.length + 1) }
+                        result.push(...addPrefix(getEntity(entity), indent))
+                    }
+                }
+            }
+            result.push('}', '')
+            return result
+        }
+
+        const getEntity = v => {
+            if (v.members) return stringifyMessage(v)
+            if (v.enumValues?.length) return stringifyEnum(v)
+            return [`// Unknown entity ${v.name}`]
+        }
+
+        for (const v of Object.values(modInfo.identifiers))
+            if (!moduleIndentationMap[v.name]?.indentation?.length)
+                decodedProtoMap[v.name] = getEntity(v).join('\n')
+    }
+
+    const body = Object.keys(decodedProtoMap).sort().map(k => decodedProtoMap[k]).join('\n')
+    return `syntax = "proto3";\npackage proto;\n${version ? `\n/// WhatsApp Version: ${version}\n` : ''}\n${body}`
+}
+
+export function parseBundle(bundle, version) {
+    const sources = Array.isArray(bundle) ? bundle : [bundle]
+    const { modulesInfo, moduleIndentationMap } = extractSchema(sources)
+    return generateProto3(modulesInfo, moduleIndentationMap, version)
+}
+
+export async function parseAndWriteProto(bundle, version, outPath = PROTO_FILE) {
+    const protoText = parseBundle(bundle, version)
+    const tmp = outPath + '.tmp'
+    writeFileSync(tmp, protoText, 'utf8')
+    renameSync(tmp, outPath)
+    const unknown = [...protoText.matchAll(/\/\/ Unknown entity (.+)/g)].map(m => m[1])
+    if (unknown.length) logger.warn(`[WAProto] ${unknown.length} unknown entities: ${unknown.join(', ')}`)
+    return {
+        messageCount: Object.values(modulesInfo).reduce((s, m) => s + Object.keys(m.identifiers || {}).length, 0),
+        unknownCount: unknown.length,
+    }
 }