dcodeindra-baileyspro 2.3.9

package/lib/Utils/signal.js

@@ -0,0 +1,154 @@
+"use strict"
+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 createSignalIdentity = (wid, accountSignatureKey) => {
+return {
+identifier: { name: wid, deviceId: 0 },
+identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+}
+}
+const getPreKeys = async ({ get }, min, limit) => {
+const idList = []
+for (let id = min; id < limit; id++) {
+idList.push(id.toString())
+}
+return get('pre-key', idList)
+}
+const generateOrGetPreKeys = (creds, range) => {
+const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+const remaining = range - avaliable
+const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+const newPreKeys = {}
+if (remaining > 0) {
+for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+}
+}
+return {
+newPreKeys,
+lastPreKeyId,
+preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+}
+}
+const xmppSignedPreKey = (key) => ({
+tag: 'skey',
+attrs: {},
+content: [
+{ tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
+{ tag: 'value', attrs: {}, content: key.keyPair.public },
+{ tag: 'signature', attrs: {}, content: key.signature }
+]
+})
+const xmppPreKey = (pair, id) => ({
+tag: 'key',
+attrs: {},
+content: [
+{ tag: 'id', attrs: {}, content: generics_1.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')
+}) : undefined)
+const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+for (const node of nodes) {
+WABinary_1.assertNodeErrorFree(node)
+}
+// Most of the work in repository.injectE2ESession is CPU intensive, not IO
+// So Promise.all doesn't really help here,
+// but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+// 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)
+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 jid = node.attrs.jid
+const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+await repository.injectE2ESession({
+jid,
+session: {
+registrationId: registrationId,
+identityKey: crypto_1.generateSignalPubKey(identity),
+signedPreKey: extractKey(signedKey),
+preKey: extractKey(key)
+}
+})
+}))
+}
+}
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+const extracted = []
+for (const userResult of result) {
+const { devices, id } = userResult
+const { user } = WABinary_1.jidDecode(id)
+const deviceList = devices?.deviceList
+if (Array.isArray(deviceList)) {
+for (const { id: device, keyIndex } of deviceList) {
+if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+(myUser !== user || myDevice !== device) && // either different user or if me user, not this device
+(device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+) {
+extracted.push({ user, device })
+}
+}
+}
+}
+return extracted
+}
+/**
+* get the next N keys for upload or processing
+* @param count number of pre-keys to get or generate
+*/
+const getNextPreKeys = async ({ creds, keys }, count) => {
+const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
+const update = {
+nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+}
+await keys.set({ 'pre-key': newPreKeys })
+const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+return { update, preKeys }
+}
+const getNextPreKeysNode = async (state, count) => {
+const { creds } = state
+const { update, preKeys } = await getNextPreKeys(state, count)
+const node = {
+tag: 'iq',
+attrs: {
+xmlns: 'encrypt',
+type: 'set',
+to: WABinary_1.S_WHATSAPP_NET,
+},
+content: [
+{ tag: 'registration', attrs: {}, content: generics_1.encodeBigEndian(creds.registrationId) },
+{ tag: 'type', attrs: {}, content: Defaults_1.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)
+]
+}
+return { update, node }
+}
+module.exports = {
+createSignalIdentity, 
+getPreKeys, 
+generateOrGetPreKeys, 
+xmppSignedPreKey, 
+xmppPreKey, 
+parseAndInjectE2ESessions, 
+extractDeviceJids, 
+getNextPreKeys, 
+getNextPreKeysNode
+}

package/lib/Utils/use-mongo-file-auth-state.d.ts

@@ -0,0 +1,5 @@
+import { AuthenticationState } from '../Types'
+export declare const useMongoFileAuthState: (collection: string) => Promise<{
+state: AuthenticationState
+saveCreds: () => Promise<void>
+}>

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

@@ -0,0 +1,75 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const WAProto_1 = require("../../WAProto")
+const auth_utils_1 = require("./auth-utils")
+const generics_1 = require("./generics")
+/*
+code from amiruldev readjusted by @irull2nd, don't delete WM!
+*/
+const useMongoFileAuthState = async (collection) => {
+const writeData = (data,id) => {
+const informationToStore = JSON.parse(
+JSON.stringify(data, generics_1.BufferJSON.replacer)
+)
+const update = {
+$set: {
+...informationToStore,
+},
+}
+return collection.updateOne({_id: id},update, {upsert: true})
+}
+const readData = async (id) => {
+try {
+const data = JSON.stringify(await collection.findOne({_id: id}))
+return JSON.parse(data, generics_1.BufferJSON.reviver)
+} catch (err) {
+console.log(err)
+}
+}
+const removeData = async (id) => {
+try{
+await collection.deleteOne({_id: id})
+}catch(err){
+console.log('error',err)
+}
+}
+const creds = (await readData('creds')) || auth_utils_1.initAuthCreds()
+return{
+state:{
+creds,
+keys: {
+get: async (type,ids)=> {
+const data = {}
+await Promise
+.all(
+ids.map(async (id) => {
+let value = await readData(`${type}-${id}`)
+if(type === "app-state-sync-key"){
+value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(data)
+}
+data[id] = value
+})
+)
+return data
+},
+set: async (data) => {
+const tasks = []
+for (const category of Object.keys(data)){
+for (const id of Object.keys(data[category])){
+const value = data[category][id]
+const key = `${category}-${id}`
+tasks.push(value? writeData(value,key) : removeData(key))
+}
+}
+await Promise.all(tasks)
+},
+},
+},
+saveCreds: () => {
+return writeData(creds, "creds")
+}
+}
+}
+module.exports = {
+useMongoFileAuthState
+}

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticationState } from '../Types'
+/**
+* stores the full authentication state in a single folder.
+* Far more efficient than singlefileauthstate
+*
+* Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+* Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+* */
+export declare const useMultiFileAuthState: (folder: string) => Promise<{
+state: AuthenticationState
+saveCreds: () => Promise<void>
+}>

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

@@ -0,0 +1,123 @@
+"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")
+// 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
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map()
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+let mutex = fileLocks.get(path)
+if (!mutex) {
+mutex = new async_mutex_1.Mutex() 
+fileLocks.set(path, mutex)
+}
+return mutex
+}
+/**
+* stores the full authentication state in a single folder.
+* Far more efficient than singlefileauthstate
+*
+* Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+* Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+* */
+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 mutex = getFileLock(filePath)
+return mutex.acquire().then(async (release) => {
+try {
+await promises_1.writeFile(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
+} finally {
+release()
+}
+})
+}
+const readData = async (file) => {
+try {
+const filePath = path_1.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' })
+} finally {
+release()
+}
+})
+return JSON.parse(data, generics_1.BufferJSON.reviver)
+} catch (error) {
+return null
+}
+}
+const removeData = async (file) => {
+try {
+const filePath = path_1.join(folder, fixFileName(file))
+const mutex = getFileLock(filePath)
+await mutex.acquire().then(async (release) => {
+try {
+await promises_1.unlink(filePath)
+} finally {
+release()
+}
+})
+} catch {}
+}
+const folderInfo = await promises_1.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 })
+}
+const fixFileName = (file) => { 
+return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
+}
+const creds = await readData('creds.json') || auth_utils_1.initAuthCreds()
+return {
+state: {
+creds,
+keys: {
+get: async (type, ids) => {
+const data = {}
+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)
+}
+data[id] = value
+}))
+return data
+},
+set: async (data) => {
+const tasks = []
+for (const category in data) {
+for (const id in data[category]) {
+const value = data[category][id]
+const file = `${category}-${id}.json`
+tasks.push(value ? writeData(value, file) : removeData(file))
+}
+}
+await Promise.all(tasks)
+}
+}
+},
+saveCreds: async () => {
+return writeData(creds, 'creds.json')
+}
+}
+}
+module.exports = {
+useMultiFileAuthState
+}

package/lib/Utils/use-single-file-auth-state.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from './logger'
+import type { AuthenticationState } from '../Types'
+/**
+* @deprecated use multi file auth state instead please
+* stores the full authentication state in a single JSON file
+*
+* DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+* */
+export declare const useSingleFileAuthState: (filename: string, logger?: ILogger) => {
+state: AuthenticationState
+saveState: () => void
+}

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

@@ -0,0 +1,75 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const WAProto_1 = require("../../WAProto")
+const auth_utils_1 = require("./auth-utils")
+const generics_1 = require("./generics")
+// useless key map only there to maintain backwards compatibility
+// do not use in your own systems please
+const KEY_MAP = {
+'pre-key': 'preKeys',
+'session': 'sessions',
+'sender-key': 'senderKeys',
+'app-state-sync-key': 'appStateSyncKeys',
+'app-state-sync-version': 'appStateVersions',
+'sender-key-memory': 'senderKeyMemory'
+}
+/**
+* @deprecated use multi file auth state instead please
+* stores the full authentication state in a single JSON file
+*
+* DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+* */
+const useSingleFileAuthState = (filename, logger) => {
+// require fs here so that in case "fs" is not available -- the app does not crash
+const { readFileSync, writeFileSync, existsSync } = require('fs')
+let creds
+let keys = {}
+// save the authentication state to a file
+const saveState = () => {
+logger && logger.trace('saving auth state')
+writeFileSync(filename, 
+// BufferJSON replacer utility saves buffers nicely
+JSON.stringify({ creds, keys }, generics_1.BufferJSON.replacer, 2))
+}
+if (existsSync(filename)) {
+const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), generics_1.BufferJSON.reviver)
+creds = result.creds
+keys = result.keys
+}
+else {
+creds = auth_utils_1.initAuthCreds()
+keys = {}
+}
+return {
+state: {
+creds,
+keys: {
+get: (type, ids) => {
+const key = KEY_MAP[type]
+return ids.reduce((dict, id) => {
+let value = keys[key]?.[id]
+if (value) {
+if (type === 'app-state-sync-key') {
+value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+}
+dict[id] = value
+}
+return dict
+}, {})
+},
+set: (data) => {
+for (const _key in data) {
+const key = KEY_MAP[_key]
+keys[key] = keys[key] || {}
+Object.assign(keys[key], data[_key])
+}
+saveState()
+}
+}
+},
+saveState
+}
+}
+module.exports = {
+useSingleFileAuthState
+}

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,10 @@
+import { proto } from '../../WAProto'
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types'
+import { BinaryNode } from '../WABinary'
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, 'advSecretKey' | 'signedIdentityKey' | 'signalIdentities'>) => {
+creds: Partial<AuthenticationCreds>
+reply: BinaryNode
+}
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array

package/lib/Utils/validate-connection.js

@@ -0,0 +1,174 @@
+"use strict"
+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 getUserAgent = (config) => {
+return {
+appVersion: {
+primary: config.version[0],
+secondary: config.version[1],
+tertiary: config.version[2],
+},
+platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
+releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+osVersion: '0.1',
+device: 'Desktop',
+osBuildNumber: '0.1',
+localeLanguageIso6391: 'en',
+mnc: '000',
+mcc: '000',
+localeCountryIso31661Alpha2: config.countryCode,
+}
+}
+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
+}
+const getWebInfo = (config) => {
+let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
+webSubPlatform = PLATFORM_MAP[config.browser[0]]
+}
+return { webSubPlatform }
+}
+const getClientPayload = (config) => {
+const payload = {
+connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+userAgent: getUserAgent(config),
+}
+payload.webInfo = getWebInfo(config)
+return payload
+}
+const generateLoginNode = (userJid, config) => {
+const { user, device } = WABinary_1.jidDecode(userJid)
+const payload = {
+...getClientPayload(config),
+passive: false,
+pull: true,
+username: +user,
+device: device,
+}
+return WAProto_1.proto.ClientPayload.fromObject(payload)
+}
+const getPlatformType = (platform) => {
+const platformType = platform.toUpperCase()
+return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.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')
+.update(config.version.join('.')) // join as string
+.digest()
+const companion = {
+os: config.browser[0],
+platformType: getPlatformType(config.browser[1]),
+requireFullSync: config.syncFullHistory,
+}
+const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+const registerPayload = {
+...getClientPayload(config),
+passive: false,
+pull: false,
+devicePairingData: {
+buildHash: appVersionBuf,
+deviceProps: companionProto,
+eRegid: generics_1.encodeBigEndian(registrationId),
+eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+eIdent: signedIdentityKey.public,
+eSkeyId: generics_1.encodeBigEndian(signedPreKey.keyId, 3),
+eSkeyVal: signedPreKey.keyPair.public,
+eSkeySig: signedPreKey.signature,
+},
+}
+return WAProto_1.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')
+if (!deviceIdentityNode || !deviceNode) {
+throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza })
+}
+const bizName = businessNode?.attrs?.name
+const jid = deviceNode.attrs.jid
+const { details, hmac } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
+// check HMAC matches
+const advSign = crypto_2.hmacSign(details, Buffer.from(advSecretKey, 'base64'))
+if (Buffer.compare(hmac, advSign) !== 0) {
+throw new boom_1.Boom('Invalid account signature')
+}
+const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details)
+const { accountSignatureKey, accountSignature, details: deviceDetails } = account
+// verify the device signature matches
+const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public])
+if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+throw new boom_1.Boom('Failed to verify account signature')
+}
+// sign the details with our identity key
+const deviceMsg = Buffer.concat([Buffer.from([6, 1]), deviceDetails, signedIdentityKey.public, accountSignatureKey])
+account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
+const identity = signal_1.createSignalIdentity(jid, accountSignatureKey)
+const accountEnc = encodeSignedDeviceIdentity(account, false)
+const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
+const reply = {
+tag: 'iq',
+attrs: {
+to: WABinary_1.S_WHATSAPP_NET,
+type: 'result',
+id: msgId,
+},
+content: [
+{
+tag: 'pair-device-sign',
+attrs: {},
+content: [
+{
+tag: 'device-identity',
+attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+content: accountEnc
+}
+]
+}
+]
+}
+const authUpdate = {
+account,
+me: { id: jid, name: bizName },
+signalIdentities: [
+...(signalIdentities || []),
+identity
+],
+platform: platformNode?.attrs?.name
+}
+return {
+creds: authUpdate,
+reply
+}
+}
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+account = { ...account }
+// set to null if we are not to include the signature key
+// or if we are including the signature key but it is empty
+if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+account.accountSignatureKey = null
+}
+return WAProto_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
+}
+module.exports = {
+generateLoginNode, 
+generateRegistrationNode, 
+configureSuccessfulPairing, 
+encodeSignedDeviceIdentity
+}

package/lib/WABinary/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const TAGS: {
+LIST_EMPTY: number
+DICTIONARY_0: number
+DICTIONARY_1: number
+DICTIONARY_2: number
+DICTIONARY_3: number
+AD_JID: number
+LIST_8: number
+LIST_16: number
+JID_PAIR: number
+HEX_8: number
+BINARY_8: number
+BINARY_20: number
+BINARY_32: number
+NIBBLE_8: number
+PACKED_MAX: number
+SINGLE_BYTE_MAX: number
+STREAM_END: number
+}
+export declare const DOUBLE_BYTE_TOKENS: string[][]
+export declare const SINGLE_BYTE_TOKENS: (string | null)[]
+export declare const TOKEN_MAP: {
+[token: string]: {
+dict?: number
+index: number
+}
+}