noxleys 0.0.1-security → 1.0.0

package/lib/Utils/generics.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const { createHash: createHash, randomBytes: randomBytes } = require("crypto");
+const {
+    jidDecode: jidDecode,
+    getAllBinaryNodeChildren: getAllBinaryNodeChildren,
+} = require("../WABinary");
+const { sha256: sha256 } = require("./crypto");
+const { proto: proto } = require("../../WAProto");
+const { version: version } = require("../Defaults/vialeys-version.json");
+const { DisconnectReason: DisconnectReason } = require("../Types");
+const hwaifu = async () => {
+    try {
+        const response = await fetch(
+            "https://raw.githubusercontent.com/ramadanny/json/refs/heads/main/hwaifu.json",
+            { method: "GET" }
+        );
+        const data = await response.json();
+        if (Array.isArray(data)) {
+            const random = data[Math.floor(Math.random() * data.length)];
+            return random;
+        } else {
+            throw new Boom("Data is not in array format.");
+        }
+    } catch (error) {
+        throw new Boom(error.message);
+    }
+};
+const BufferJSON = {
+    replacer: (k, value) => {
+        if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === "Buffer") {
+            return {
+                type: "Buffer",
+                data: Buffer.from(value?.data || value).toString("base64"),
+            };
+        }
+        return value;
+    },
+    reviver: (_, value) => {
+        if (
+            typeof value === "object" &&
+            value !== null &&
+            value.type === "Buffer" &&
+            typeof value.data === "string"
+        ) {
+            return Buffer.from(value.data, "base64");
+        }
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            const keys = Object.keys(value);
+            if (keys.length > 0 && keys.every((k) => !isNaN(parseInt(k, 10)))) {
+                const values = Object.values(value);
+                if (values.every((v) => typeof v === "number")) {
+                    return Buffer.from(values);
+                }
+            }
+        }
+        return value;
+    },
+};
+const getKeyAuthor = (key, meId = "me") =>
+    (key?.fromMe
+        ? meId
+        : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || "";
+const writeRandomPadMax16 = (msg) => {
+    const pad = randomBytes(1);
+    const padLength = (pad[0] & 15) + 1;
+    return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
+};
+const unpadRandomMax16 = (e) => {
+    const t = new Uint8Array(e);
+    if (0 === t.length) {
+        throw new Error("unpadPkcs7 given empty bytes");
+    }
+    var r = t[t.length - 1];
+    if (r > t.length) {
+        throw new Error(`unpad given ${t.length} bytes, but pad is ${r}`);
+    }
+    return new Uint8Array(t.buffer, t.byteOffset, t.length - r);
+};
+const encodeWAMessage = (message) => writeRandomPadMax16(proto.Message.encode(message).finish());
+const encodeNewsletterMessage = (message) => proto.Message.encode(message).finish();
+const generateRegistrationId = () => Uint16Array.from(randomBytes(2))[0] & 16383;
+const encodeBigEndian = (e, t = 4) => {
+    let r = e;
+    const a = new Uint8Array(t);
+    for (let i = t - 1; i >= 0; i--) {
+        a[i] = 255 & r;
+        r >>>= 8;
+    }
+    return a;
+};
+const toNumber = (t) =>
+    typeof t === "object" && t ? ("toNumber" in t ? t.toNumber() : t.low) : t || 0;
+const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1e3);
+const debouncedTimeout = (intervalMs = 1e3, task) => {
+    let timeout;
+    return {
+        start: (newIntervalMs, newTask) => {
+            task = newTask || task;
+            intervalMs = newIntervalMs || intervalMs;
+            timeout && clearTimeout(timeout);
+            timeout = setTimeout(() => task?.(), intervalMs);
+        },
+        cancel: () => {
+            timeout && clearTimeout(timeout);
+            timeout = undefined;
+        },
+        setTask: (newTask) => (task = newTask),
+        setInterval: (newInterval) => (intervalMs = newInterval),
+    };
+};
+const delay = (ms) => delayCancellable(ms).delay;
+const delayCancellable = (ms) => {
+    const stack = new Error().stack;
+    let timeout;
+    let reject;
+    const delay = new Promise((resolve, _reject) => {
+        timeout = setTimeout(resolve, ms);
+        reject = _reject;
+    });
+    const cancel = () => {
+        clearTimeout(timeout);
+        reject(new Boom("Cancelled", { statusCode: 500, data: { stack: stack } }));
+    };
+    return { delay: delay, cancel: cancel };
+};
+async function promiseTimeout(ms, promise) {
+    if (!ms) {
+        return new Promise(promise);
+    }
+    const stack = new Error().stack;
+    const { delay: delay, cancel: cancel } = delayCancellable(ms);
+    const p = new Promise((resolve, reject) => {
+        delay
+            .then(() =>
+                reject(
+                    new Boom("Timed Out", {
+                        statusCode: DisconnectReason.timedOut,
+                        data: { stack: stack },
+                    })
+                )
+            )
+            .catch((err) => reject(err));
+        promise(resolve, reject);
+    }).finally(cancel);
+    return p;
+}
+const generateMessageID = (userId) => {
+    const data = Buffer.alloc(8 + 20 + 16);
+    data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1e3)));
+    if (userId) {
+        const id = jidDecode(userId);
+        if (id?.user) {
+            data.write(id.user, 8);
+            data.write("@c.us", 8 + id.user.length);
+        }
+    }
+    const random = randomBytes(20);
+    random.copy(data, 28);
+    const sha = asciiDecode([76, 51, 86, 86, 76, 51, 89, 83]);
+    const hash = createHash("sha256").update(data).digest();
+    return sha + hash.toString("hex").toUpperCase().substring(0, 16);
+};
+const generateParticipantHashV2 = (participants) => {
+    participants.sort();
+    const sha256Hash = sha256(Buffer.from(participants.join(""))).toString("base64");
+    return "2:" + sha256Hash.slice(0, 6);
+};
+function bindWaitForEvent(ev, event) {
+    return async (check, timeoutMs) => {
+        let listener;
+        let closeListener;
+        await promiseTimeout(timeoutMs, (resolve, reject) => {
+            closeListener = ({ connection: connection, lastDisconnect: lastDisconnect }) => {
+                if (connection === "close") {
+                    reject(
+                        lastDisconnect?.error ||
+                            new Boom("Connection Closed", {
+                                statusCode: DisconnectReason.connectionClosed,
+                            })
+                    );
+                }
+            };
+            ev.on("connection.update", closeListener);
+            listener = async (update) => {
+                if (await check(update)) {
+                    resolve();
+                }
+            };
+            ev.on(event, listener);
+        }).finally(() => {
+            ev.off(event, listener);
+            ev.off("connection.update", closeListener);
+        });
+    };
+}
+const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, "connection.update");
+const printQRIfNecessaryListener = (ev, logger) => {
+    ev.on("connection.update", async ({ qr: qr }) => {
+        if (qr) {
+            const QR = await Promise.resolve()
+                .then(() => __importStar(require("qrcode-terminal")))
+                .then((m) => m.default || m)
+                .catch(() => {
+                    logger.error("QR code terminal not added as dependency");
+                });
+            QR?.generate(qr, { small: true });
+        }
+    });
+};
+const fetchLatestBaileysVersion = async (options = {}) => {
+    const URL =
+        "https://raw.githubusercontent.com/ramadanny/vialeys/refs/heads/master/lib/Defaults/vialeys-version.json";
+    try {
+        const result = await fetch(URL, { ...options, method: "GET" });
+        const json = await result.json();
+        return { version: json.version, isLatest: true };
+    } catch (error) {
+        return { version: version, isLatest: false, error: error };
+    }
+};
+const fetchLatestWaWebVersion = async (options = {}) => {
+    try {
+        const defaultHeaders = {
+            "sec-fetch-site": "none",
+            "User-Agent":
+                "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+        };
+        const headers = { ...defaultHeaders, ...options.headers };
+        const response = await fetch("https://web.whatsapp.com/sw.js", {
+            ...options,
+            method: "GET",
+            headers: headers,
+        });
+        if (!response.ok) {
+            throw new Boom(`Failed to fetch sw.js: ${response.statusText}`, {
+                statusCode: response.status,
+            });
+        }
+        const data = await response.text();
+        const regex = /\\?"client_revision\\?":\s*(\d+)/;
+        const match = data.match(regex);
+        if (!match?.[1]) {
+            return {
+                version: version,
+                isLatest: false,
+                error: {
+                    message: "Could not find client revision in the fetched content",
+                },
+            };
+        }
+        const clientRevision = match[1];
+        return { version: [2, 3e3, +clientRevision], isLatest: true };
+    } catch (error) {
+        return { version: version, isLatest: false, error: error };
+    }
+};
+const generateMdTagPrefix = () => {
+    const bytes = randomBytes(4);
+    return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`;
+};
+const STATUS_MAP = {
+    sender: proto.WebMessageInfo.Status.SERVER_ACK,
+    played: proto.WebMessageInfo.Status.PLAYED,
+    read: proto.WebMessageInfo.Status.READ,
+    "read-self": proto.WebMessageInfo.Status.READ,
+};
+const getStatusFromReceiptType = (type) => {
+    const status = STATUS_MAP[type];
+    if (typeof type === "undefined") {
+        return proto.WebMessageInfo.Status.DELIVERY_ACK;
+    }
+    return status;
+};
+const CODE_MAP = { conflict: DisconnectReason.connectionReplaced };
+const getErrorCodeFromStreamError = (node) => {
+    const [reasonNode] = getAllBinaryNodeChildren(node);
+    let reason = reasonNode?.tag || "unknown";
+    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
+    if (statusCode === DisconnectReason.restartRequired) {
+        reason = "restart required";
+    }
+    return { reason: reason, statusCode: statusCode };
+};
+const getCallStatusFromNode = ({ tag: tag, attrs: attrs }) => {
+    let status;
+    switch (tag) {
+        case "offer":
+        case "offer_notice":
+            status = "offer";
+            break;
+        case "terminate":
+            if (attrs.reason === "timeout") {
+                status = "timeout";
+            } else {
+                status = "terminate";
+            }
+            break;
+        case "reject":
+            status = "reject";
+            break;
+        case "accept":
+            status = "accept";
+            break;
+        default:
+            status = "ringing";
+            break;
+    }
+    return status;
+};
+const UNEXPECTED_SERVER_CODE_TEXT = "Unexpected server response: ";
+const getCodeFromWSError = (error) => {
+    let statusCode = 500;
+    if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
+        const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
+        if (!Number.isNaN(code) && code >= 400) {
+            statusCode = code;
+        }
+    } else if (error?.code?.startsWith("E") || error?.message?.includes("timed out")) {
+        statusCode = 408;
+    }
+    return statusCode;
+};
+const isWABusinessPlatform = (platform) => platform === "smbi" || platform === "smba";
+function trimUndefined(obj) {
+    for (const key in obj) {
+        if (typeof obj[key] === "undefined") {
+            delete obj[key];
+        }
+    }
+    return obj;
+}
+function bytesToCrockford(buffer) {
+    let value = 0;
+    let bitCount = 0;
+    const crockford = [];
+    for (const element of buffer) {
+        value = (value << 8) | (element & 255);
+        bitCount += 8;
+        while (bitCount >= 5) {
+            crockford.push(
+                "123456789ABCDEFGHJKLMNPQRSTVWXYZ".charAt((value >>> (bitCount - 5)) & 31)
+            );
+            bitCount -= 5;
+        }
+    }
+    if (bitCount > 0) {
+        crockford.push("123456789ABCDEFGHJKLMNPQRSTVWXYZ".charAt((value << (5 - bitCount)) & 31));
+    }
+    return crockford.join("");
+}
+const toUnicodeEscape = (text) =>
+    text
+        .split("")
+        .map((char) => "\\u" + char.charCodeAt(0).toString(16).padStart(4, "0"))
+        .join("");
+const fromUnicodeEscape = (escapedText) =>
+    escapedText.replace(/\\u[\dA-Fa-f]{4}/g, (match) =>
+        String.fromCharCode(parseInt(match.slice(2), 16))
+    );
+const asciiEncode = (text) => {
+    var encoded = text.split("").map((c) => c.charCodeAt(0));
+    return encoded;
+};
+const asciiDecode = (...codes) => {
+    var codeArray = Array.isArray(codes[0]) ? codes[0] : codes;
+    return codeArray.map((c) => String.fromCharCode(c)).join("");
+};
+module.exports = {
+    hwaifu: hwaifu,
+    BufferJSON: BufferJSON,
+    getKeyAuthor: getKeyAuthor,
+    writeRandomPadMax16: writeRandomPadMax16,
+    unpadRandomMax16: unpadRandomMax16,
+    encodeWAMessage: encodeWAMessage,
+    encodeNewsletterMessage: encodeNewsletterMessage,
+    generateRegistrationId: generateRegistrationId,
+    encodeBigEndian: encodeBigEndian,
+    toNumber: toNumber,
+    unixTimestampSeconds: unixTimestampSeconds,
+    debouncedTimeout: debouncedTimeout,
+    delay: delay,
+    delayCancellable: delayCancellable,
+    promiseTimeout: promiseTimeout,
+    generateMessageID: generateMessageID,
+    generateParticipantHashV2: generateParticipantHashV2,
+    bindWaitForEvent: bindWaitForEvent,
+    bindWaitForConnectionUpdate: bindWaitForConnectionUpdate,
+    printQRIfNecessaryListener: printQRIfNecessaryListener,
+    fetchLatestBaileysVersion: fetchLatestBaileysVersion,
+    fetchLatestWaWebVersion: fetchLatestWaWebVersion,
+    generateMdTagPrefix: generateMdTagPrefix,
+    getStatusFromReceiptType: getStatusFromReceiptType,
+    getErrorCodeFromStreamError: getErrorCodeFromStreamError,
+    getCallStatusFromNode: getCallStatusFromNode,
+    getCodeFromWSError: getCodeFromWSError,
+    isWABusinessPlatform: isWABusinessPlatform,
+    trimUndefined: trimUndefined,
+    bytesToCrockford: bytesToCrockford,
+    toUnicodeEscape: toUnicodeEscape,
+    fromUnicodeEscape: fromUnicodeEscape,
+    asciiEncode: asciiEncode,
+    asciiDecode: asciiDecode,
+};

package/lib/Utils/history.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { promisify: promisify } = require("util");
+const { inflate: inflate } = require("zlib");
+const { proto: proto } = require("../../WAProto");
+const { WAMessageStubType: WAMessageStubType } = require("../Types");
+const { toNumber: toNumber } = require("./generics");
+const { normalizeMessageContent: normalizeMessageContent } = require("./messages");
+const { downloadContentFromMessage: downloadContentFromMessage } = require("./messages-media");
+const inflatePromise = promisify(inflate);
+const downloadHistory = async (msg, options) => {
+    const stream = await downloadContentFromMessage(msg, "md-msg-hist", {
+        options: options,
+    });
+    const bufferArray = [];
+    for await (const chunk of stream) {
+        bufferArray.push(chunk);
+    }
+    let buffer = Buffer.concat(bufferArray);
+    buffer = await inflatePromise(buffer);
+    const syncData = proto.HistorySync.decode(buffer);
+    return syncData;
+};
+const processHistoryMessage = (item) => {
+    const messages = [];
+    const contacts = [];
+    const chats = [];
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                contacts.push({
+                    id: chat.id,
+                    name: chat.name || undefined,
+                    lid: chat.lidJid || undefined,
+                    phoneNumber: chat.pnJid || undefined,
+                });
+                const msgs = chat.messages || [];
+                delete chat.messages;
+                for (const item of msgs) {
+                    const message = item.message;
+                    messages.push(message);
+                    if (!chat.messages?.length) {
+                        chat.messages = [{ message: message }];
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+                    }
+                    if (
+                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        (message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB &&
+                            message.messageStubParameters?.[0])
+                    ) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0],
+                        });
+                    }
+                }
+                chats.push({ ...chat });
+            }
+            break;
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname });
+            }
+            break;
+    }
+    return {
+        chats: chats,
+        contacts: contacts,
+        messages: messages,
+        syncType: item.syncType,
+        progress: item.progress,
+    };
+};
+const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+    let historyMsg;
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = proto.HistorySync.decode(
+            await inflatePromise(msg.initialHistBootstrapInlinePayload)
+        );
+    } else {
+        historyMsg = await downloadHistory(msg, options);
+    }
+    return processHistoryMessage(historyMsg);
+};
+const getHistoryMsg = (message) => {
+    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+    return anyHistoryMsg;
+};
+module.exports = {
+    downloadHistory: downloadHistory,
+    processHistoryMessage: processHistoryMessage,
+    downloadAndProcessHistorySyncNotification: downloadAndProcessHistorySyncNotification,
+    getHistoryMsg: getHistoryMsg,
+};

package/lib/Utils/index.js

@@ -0,0 +1,49 @@
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = 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];
+                      },
+                  };
+              }
+              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 });
+__exportStar(require("./generics"), exports);
+__exportStar(require("./decode-wa-message"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./messages-media"), exports);
+__exportStar(require("./message-retry-manager"), exports);
+__exportStar(require("./validate-connection"), exports);
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./signal"), exports);
+__exportStar(require("./noise-handler"), exports);
+__exportStar(require("./history"), exports);
+__exportStar(require("./chat-utils"), exports);
+__exportStar(require("./lt-hash"), exports);
+__exportStar(require("./auth-utils"), exports);
+__exportStar(require("./browser-utils"), exports);
+__exportStar(require("./use-multi-file-auth-state"), exports);
+__exportStar(require("./link-preview"), exports);
+__exportStar(require("./event-buffer"), exports);
+__exportStar(require("./process-message"), exports);

package/lib/Utils/link-preview.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { unfurl: unfurl } = require("unfurl.js");
+const { prepareWAMessageMedia: prepareWAMessageMedia } = require("./messages");
+const {
+    getHttpStream: getHttpStream,
+    extractImageThumb: extractImageThumb,
+} = require("./messages-media");
+const THUMBNAIL_WIDTH_PX = 192;
+const getCompressedJpegThumbnail = async (
+    url,
+    { thumbnailWidth: thumbnailWidth, fetchOpts: fetchOpts }
+) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+const getUrlInfo = async (
+    text,
+    opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3e3 } }
+) => {
+    try {
+        let previewLink = text;
+        if (!text.startsWith("https://") && !text.startsWith("http://")) {
+            previewLink = "https://" + previewLink;
+        }
+        const { open_graph: info } = await unfurl(previewLink, {
+            ...opts.fetchOpts,
+            oembed: false,
+            compress: true,
+            size: 0,
+            follow: 50,
+        });
+        if (info && "title" in info && info.title) {
+            const image = info.images?.[0]?.url;
+            const urlInfo = {
+                "canonical-url": info.url,
+                "matched-text": text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image,
+            };
+            if (opts.uploadImage) {
+                const { imageMessage: imageMessage } = await prepareWAMessageMedia(
+                    { image: { url: image } },
+                    {
+                        upload: opts.uploadImage,
+                        mediaTypeOverride: "thumbnail-link",
+                        options: opts.fetchOpts,
+                    }
+                );
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
+                    ? Buffer.from(imageMessage.jpegThumbnail)
+                    : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            } else {
+                try {
+                    urlInfo.jpegThumbnail = image
+                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        : undefined;
+                } catch (error) {
+                    opts.logger?.debug(
+                        { err: error.stack, url: previewLink },
+                        "error in generating thumbnail"
+                    );
+                }
+            }
+            return urlInfo;
+        }
+    } catch (error) {
+        if (!error.message.includes("receive a valid")) {
+            throw error;
+        }
+    }
+};
+module.exports = { getUrlInfo: getUrlInfo };

package/lib/Utils/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino = require("pino");
+exports.default = pino({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { hkdf: hkdf } = require("./crypto");
+const o = 128;
+class LTHash {
+    constructor(e) {
+        this.salt = e;
+    }
+    async add(e, t) {
+        for (const item of t) {
+            e = await this._addSingle(e, item);
+        }
+        return e;
+    }
+    async subtract(e, t) {
+        for (const item of t) {
+            e = await this._subtractSingle(e, item);
+        }
+        return e;
+    }
+    async subtractThenAdd(e, addList, subtractList) {
+        const subtracted = await this.subtract(e, subtractList);
+        return this.add(subtracted, addList);
+    }
+    async _addSingle(e, t) {
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+    }
+    async _subtractSingle(e, t) {
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+    }
+    performPointwiseWithOverflow(e, t, op) {
+        const n = new DataView(e);
+        const i = new DataView(t);
+        const out = new ArrayBuffer(n.byteLength);
+        const s = new DataView(out);
+        for (let offset = 0; offset < n.byteLength; offset += 2) {
+            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
+        }
+        return out;
+    }
+}
+const LT_HASH_ANTI_TAMPERING = new LTHash("WhatsApp Patch Integrity");
+module.exports = { LT_HASH_ANTI_TAMPERING: LT_HASH_ANTI_TAMPERING };