@vanzxy/baileys 1.4.1 → 1.4.2

package/cjs/lib/Utils/MessageBuilder.js

@@ -0,0 +1,2164 @@
+/**
+ * lib/Utils/MessageBuilder.js — AIRich / Button / ButtonV2 / Carousel / Toolkit
+ *
+ * Part of @vanzxy/baileys 1.3.9. Third-party attribution for the base
+ * implementation this file was adapted from is kept in /NOTICE.md
+ * (not inline here) per the original author's license terms.
+ *
+ * Vanz@Merge 15-08-26 --- Ported into @vanzxy/baileys 1.3.9 from the
+ * @blurose/baileys 1.1.13 fork (base, feature-complete) with perf defaults
+ * and message-authenticity fields backported from arslan-baileys 1.1.0 and
+ * this project's own rich-message-utils.js. See changes tagged "Vanz@" below.
+ */
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _Button_client, _Button_validateAgainstSchema, _ButtonV2_client, _Carousel_client, _AIRich_client;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Toolkit = exports.AIRich = exports.Carousel = exports.ButtonV2 = exports.Button = exports.MESSAGE_BUILDER_VERSION = void 0;
+const MESSAGE_BUILDER_VERSION = '4.6';
+exports.MESSAGE_BUILDER_VERSION = MESSAGE_BUILDER_VERSION;
+const messages_js_1 = require("./messages.js");
+const rich_message_utils_js_1 = require("./rich-message-utils.js");
+const crypto_1 = __importDefault(require("crypto"));
+const stream_1 = require("stream");
+// Vanz@Fix 15-08-26 --- sharp/fluent-ffmpeg were statically imported in the blurose source.
+// Both are optional peer deps here (see package.json peerDependenciesMeta); a static import
+// throws at module-load time when they're not installed, which would crash the entire
+// lib/Utils barrel export (and therefore bot startup) even for users who never call
+// AIRich.addImage()/addVideo()/Toolkit.*. Lazy-load them instead, matching the pattern
+// already used in messages-media.js's getImageProcessingLibrary().
+let _sharp;
+const getSharp = async () => {
+    if (_sharp === undefined) {
+        _sharp = await Promise.resolve().then(() => __importStar(require('sharp'))).then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_sharp)
+        throw new Error('sharp is required for this operation. Install it with: npm i sharp');
+    return _sharp;
+};
+let _ffmpeg;
+const getFfmpeg = async () => {
+    if (_ffmpeg === undefined) {
+        _ffmpeg = await Promise.resolve().then(() => __importStar(require('fluent-ffmpeg'))).then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_ffmpeg)
+        throw new Error('fluent-ffmpeg is required for this operation. Install it with: npm i fluent-ffmpeg');
+    return _ffmpeg;
+};
+function extractIE(text, { extract = true, hyperlink = true, citation = true, latex = true } = {}) {
+    if (!extract) {
+        return {
+            text,
+            ie: [],
+            inline_entities: [],
+        };
+    }
+    const createIE = (type, ie) => {
+        if (type == 'hyperlink') {
+            return {
+                key: ie.key,
+                metadata: {
+                    display_name: ie.text,
+                    is_trusted: ie.is_trusted,
+                    url: ie.url,
+                    __typename: 'GenAIInlineLinkItem',
+                },
+            };
+        }
+        if (type == 'citation') {
+            return {
+                key: ie.key,
+                metadata: {
+                    reference_id: ie.reference_id,
+                    reference_url: ie.url,
+                    reference_title: ie.url,
+                    reference_display_name: ie.url,
+                    sources: [],
+                    __typename: 'GenAISearchCitationItem',
+                },
+            };
+        }
+        if (type == 'latex') {
+            return {
+                key: ie.key,
+                metadata: {
+                    latex_expression: ie.text,
+                    latex_image: {
+                        url: ie.url,
+                        width: Number(ie.width) || 100,
+                        height: Number(ie.height) || 100,
+                    },
+                    font_height: Number(ie.font_height) || 83.333333333333,
+                    padding: Number(ie.padding) || 15,
+                    __typename: 'GenAILatexItem',
+                },
+            };
+        }
+    };
+    let ie = [];
+    let inline_entities = [];
+    let result = '';
+    let last = 0;
+    let citation_index = 1;
+    let hyperlink_index = 0;
+    let latex_index = 0;
+    let stack = [];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] == '[' && text[i - 1] != '\\') {
+            stack.push(i);
+        }
+        else if (text[i] == ']' && (text[i + 1] == '(' || text[i + 1] == '<')) {
+            let start = stack.pop();
+            if (start == null)
+                continue;
+            let open = text[i + 1];
+            let close = open == '(' ? ')' : '>';
+            let type = open == '(' ? 'link' : 'latex';
+            let end = i + 2;
+            let depth = 1;
+            while (end < text.length && depth) {
+                if (text[end] == open && text[end - 1] != '\\')
+                    depth++;
+                else if (text[end] == close && text[end - 1] != '\\')
+                    depth--;
+                end++;
+            }
+            if (depth)
+                continue;
+            let raw = text.slice(start + 1, i).trim();
+            let url = text.slice(i + 2, end - 1).trim();
+            let key;
+            let tag;
+            let data;
+            if (type == 'latex') {
+                if (!latex)
+                    continue;
+                let [txt = '', width = null, height = null, font_height = null, padding = null] = raw.split('|');
+                key = `\u004E\u0049\u0058\u0045\u004C_LATEX_${latex_index++}`;
+                tag = `{{${key}}}${txt || 'image'}{{/${key}}}`;
+                data = {
+                    type: 'latex',
+                    ie: {
+                        key,
+                        text: txt,
+                        url,
+                        width,
+                        height,
+                        font_height,
+                        padding,
+                    },
+                };
+            }
+            else if (raw) {
+                if (!hyperlink)
+                    continue;
+                const trusted = !url.startsWith('!');
+                if (!trusted) {
+                    url = url.slice(1);
+                }
+                key = `\u004E\u0049\u0058\u0045\u004C_HYPERLINK_${hyperlink_index++}`;
+                tag = `{{${key}}}${url}{{/${key}}}`;
+                data = {
+                    type: 'hyperlink',
+                    ie: {
+                        key,
+                        text: raw,
+                        url,
+                        is_trusted: trusted,
+                    },
+                };
+            }
+            else {
+                if (!citation)
+                    continue;
+                key = `\u004E\u0049\u0058\u0045\u004C_CITATION_${citation_index - 1}`;
+                tag = `{{${key}}}${url}{{/${key}}}`;
+                data = {
+                    type: 'citation',
+                    ie: {
+                        reference_id: citation_index++,
+                        key,
+                        text: '',
+                        url,
+                    },
+                };
+            }
+            result += text.slice(last, start) + tag;
+            last = end;
+            ie.push(data);
+            const entity = createIE(data.type, data.ie);
+            if (entity) {
+                inline_entities.push(entity);
+            }
+            i = end - 1;
+        }
+    }
+    result += text.slice(last);
+    return {
+        text: result,
+        ie,
+        inline_entities,
+    };
+}
+async function waitAllPromises(input) {
+    const isPromise = (v) => v && typeof v.then === 'function';
+    const isObject = (v) => v && typeof v === 'object';
+    const deep = async (v) => {
+        if (isPromise(v))
+            return deep(await v);
+        if (Array.isArray(v))
+            return Promise.all(v.map(deep));
+        if (isObject(v)) {
+            const entries = await Promise.all(Object.entries(v).map(async ([k, val]) => [k, await deep(val)]));
+            return Object.fromEntries(entries);
+        }
+        return v;
+    };
+    return deep(await input);
+}
+class Toolkit {
+    constructor() { }
+    static extractIE(text, { extract = true, hyperlink = true, citation = true, latex = true } = {}) {
+        return extractIE(text, { extract, hyperlink, citation, latex });
+    }
+    static async resize(buffer, x, y, fit = 'cover') {
+        const sharp = await getSharp();
+        return await sharp(buffer)
+            .resize(x, y, {
+            fit,
+            position: 'center',
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        })
+            .png()
+            .toBuffer();
+    }
+    static async waitAllPromises(input) {
+        return await waitAllPromises(input);
+    }
+    static async fetchBuffer(url, options = {}, { silent = true } = {}) {
+        try {
+            let response = await fetch(url, options);
+            if (!response.ok)
+                throw Error(`HTTP ${response.status}`);
+            return Buffer.from(await response.arrayBuffer());
+        }
+        catch (error) {
+            if (silent)
+                return Buffer.alloc(0);
+            throw error;
+        }
+    }
+    static async toUrl(_client, path, mediaType = 'document') {
+        if (!path)
+            throw new Error('Url or buffer needed');
+        const media = await (0, messages_js_1.prepareWAMessageMedia)({
+            [mediaType]: Buffer.isBuffer(path) ? path : { url: path },
+        }, {
+            upload: _client.waUploadToServer,
+            jid: '\u0040\u006e\u0065\u0077\u0073\u006c\u0065\u0074\u0074\u0065\u0072',
+        });
+        return Object.values(media)[0]?.url;
+    }
+    static async resolveMedia(_client, media, mediaType = 'image', { resolveUrl = false, resolveWAUrl = false, result = 'url', resize = false, width = 300, height = 300 } = {}) {
+        const isUrl = (str) => /^https?:\/\/.+/i.test(str);
+        const isWAUrl = (str) => /^https?:\/\/[^/]*\.whatsapp\.net\//i.test(str);
+        if (Array.isArray(media)) {
+            return Promise.all(media.map((item) => Toolkit.resolveMedia(_client, item, mediaType, {
+                resolveUrl,
+                resolveWAUrl,
+                result,
+                resize,
+                width,
+                height,
+            })));
+        }
+        const originalIsBuffer = Buffer.isBuffer(media);
+        if (typeof media === 'string' && isUrl(media)) {
+            if (isWAUrl(media)) {
+                if (resolveWAUrl) {
+                    media = await Toolkit.fetchBuffer(media, {}, { silent: true });
+                }
+                else if (!resolveUrl) {
+                    if (result === 'url')
+                        return media;
+                    media = await Toolkit.fetchBuffer(media, {}, { silent: true });
+                }
+            }
+            else {
+                if (!resolveUrl) {
+                    if (result === 'url')
+                        return media;
+                    media = await Toolkit.fetchBuffer(media, {}, { silent: true });
+                }
+                else {
+                    media = await Toolkit.fetchBuffer(media, {}, { silent: true });
+                }
+            }
+        }
+        if (typeof media === 'string' && !isUrl(media)) {
+            media = Buffer.from(media, 'base64');
+        }
+        if (!Buffer.isBuffer(media) || !media.length) {
+            return;
+        }
+        if (resize && Buffer.isBuffer(media)) {
+            media = await Toolkit.resize(media, width, height);
+        }
+        if (result === 'buffer') {
+            return media;
+        }
+        if (result === 'base64') {
+            return media.toString('base64');
+        }
+        if (originalIsBuffer) {
+            return Toolkit.toUrl(_client, media, mediaType);
+        }
+        return Toolkit.toUrl(_client, media, mediaType);
+    }
+    static getMp4Duration(buffer, { silent = true } = {}) {
+        try {
+            if (!Buffer.isBuffer(buffer) || buffer.length < 8) {
+                if (silent)
+                    return 0;
+                throw new Error('Invalid buffer');
+            }
+            let offset = 0;
+            while (offset < buffer.length - 8) {
+                const size = buffer.readUInt32BE(offset);
+                if (size < 8 || offset + size > buffer.length) {
+                    if (silent)
+                        return 0;
+                    throw new Error('Invalid atom size');
+                }
+                const type = buffer.toString('ascii', offset + 4, offset + 8);
+                if (type === 'moov') {
+                    let moovOffset = offset + 8;
+                    const moovEnd = offset + size;
+                    while (moovOffset < moovEnd - 8) {
+                        const childSize = buffer.readUInt32BE(moovOffset);
+                        if (childSize < 8 || moovOffset + childSize > moovEnd) {
+                            if (silent)
+                                return 0;
+                            throw new Error('Invalid child atom size');
+                        }
+                        const childType = buffer.toString('ascii', moovOffset + 4, moovOffset + 8);
+                        if (childType === 'mvhd') {
+                            const version = buffer.readUInt8(moovOffset + 8);
+                            if (version === 0) {
+                                const timescale = buffer.readUInt32BE(moovOffset + 20);
+                                const duration = buffer.readUInt32BE(moovOffset + 24);
+                                if (!timescale) {
+                                    if (silent)
+                                        return 0;
+                                    throw new Error('Invalid timescale');
+                                }
+                                return duration / timescale;
+                            }
+                            if (version === 1) {
+                                const timescale = buffer.readUInt32BE(moovOffset + 32);
+                                const duration = Number(buffer.readBigUInt64BE(moovOffset + 36));
+                                if (!timescale) {
+                                    if (silent)
+                                        return 0;
+                                    throw new Error('Invalid timescale');
+                                }
+                                return duration / timescale;
+                            }
+                        }
+                        moovOffset += childSize;
+                    }
+                }
+                offset += size;
+            }
+            if (silent)
+                return 0;
+            throw new Error('No mvhd found!');
+        }
+        catch (err) {
+            if (silent)
+                return 0;
+            throw err;
+        }
+    }
+    static getMp4Preview(videoBuffer, { time, result = 'buffer', resize = true, width = 300, height = 300, silent = true } = {}) {
+        return new Promise((resolve, reject) => {
+            const fail = (err) => {
+                if (silent) {
+                    return resolve(result === 'base64' ? '' : Buffer.alloc(0));
+                }
+                return reject(err);
+            };
+            try {
+                if (!Buffer.isBuffer(videoBuffer) || !videoBuffer.length) {
+                    return fail(new Error('videoBuffer tidak valid atau kosong'));
+                }
+                const inputStream = new stream_1.Readable({ read() { } });
+                inputStream.push(videoBuffer);
+                inputStream.push(null);
+                const outputStream = new stream_1.PassThrough();
+                const chunks = [];
+                outputStream.on('data', (chunk) => chunks.push(chunk));
+                outputStream.on('end', async () => {
+                    try {
+                        let output = Buffer.concat(chunks);
+                        if (!output.length) {
+                            return fail(new Error('Output kosong — cek format atau timestamp video'));
+                        }
+                        if (resize) {
+                            output = await Toolkit.resize(output, width, height);
+                        }
+                        return resolve(result === 'base64' ? output.toString('base64') : output);
+                    }
+                    catch (err) {
+                        return fail(err);
+                    }
+                });
+                outputStream.on('error', fail);
+                time ??= Math.min(Toolkit.getMp4Duration(videoBuffer) * 0.2, 10);
+                getFfmpeg()
+                    .then((ffmpeg) => {
+                    ffmpeg(inputStream)
+                        .outputOptions([`-ss ${time}`, '-vframes 1', '-vcodec png', '-f image2pipe'])
+                        .on('error', (err) => fail(new Error(`ffmpeg error: ${err.message}`)))
+                        .pipe(outputStream, { end: true });
+                })
+                    .catch(fail);
+            }
+            catch (err) {
+                return fail(err);
+            }
+        });
+    }
+}
+exports.Toolkit = Toolkit;
+class BaseBuilder {
+    constructor() {
+        this._title = '';
+        this._subtitle = '';
+        this._body = '';
+        this._footer = '';
+        this._contextInfo = {};
+        this._extraPayload = {};
+    }
+    setTitle(title) {
+        if (typeof title !== 'string') {
+            throw new TypeError('Title must be a string');
+        }
+        this._title = title;
+        return this;
+    }
+    setSubtitle(subtitle) {
+        if (typeof subtitle !== 'string') {
+            throw new TypeError('Subtitle must be a string');
+        }
+        this._subtitle = subtitle;
+        return this;
+    }
+    setBody(body) {
+        if (typeof body !== 'string') {
+            throw new TypeError('Body must be a string');
+        }
+        this._body = body;
+        return this;
+    }
+    setFooter(footer) {
+        if (typeof footer !== 'string') {
+            throw new TypeError('Footer must be a string');
+        }
+        this._footer = footer;
+        return this;
+    }
+    setContextInfo(obj) {
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            throw new TypeError('ContextInfo must be a plain object');
+        }
+        this._contextInfo = obj;
+        return this;
+    }
+    addPayload(obj) {
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            throw new TypeError('Payload must be a plain object');
+        }
+        Object.assign(this._extraPayload, obj);
+        return this;
+    }
+}
+class Button extends BaseBuilder {
+    constructor(client) {
+        super();
+        _Button_client.set(this, void 0);
+        if (!client) {
+            throw new Error('Socket is required');
+        }
+        __classPrivateFieldSet(this, _Button_client, client, "f");
+        this._buttons = [];
+        this._data;
+        this._currentSelectionIndex = -1;
+        this._currentSectionIndex = -1;
+        this._params = {};
+    }
+    setVideo(path, options = {}) {
+        if (!path)
+            throw new Error('Url or buffer needed');
+        Buffer.isBuffer(path) ? (this._data = { video: path, ...options }) : (this._data = { video: { url: path }, ...options });
+        return this;
+    }
+    setImage(path, options = {}) {
+        if (!path)
+            throw new Error('Url or buffer needed');
+        Buffer.isBuffer(path) ? (this._data = { image: path, ...options }) : (this._data = { image: { url: path }, ...options });
+        return this;
+    }
+    setDocument(path, options = {}) {
+        if (!path)
+            throw new Error('Url or buffer needed');
+        Buffer.isBuffer(path) ? (this._data = { document: path, ...options }) : (this._data = { document: { url: path }, ...options });
+        return this;
+    }
+    setMedia(obj) {
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            throw new TypeError('Media must be a plain object');
+        }
+        this._data = obj;
+        return this;
+    }
+    clearButtons() {
+        this._buttons = [];
+        return this;
+    }
+    setParams(obj) {
+        this._params = obj;
+        return this;
+    }
+    addButton(name, params) {
+        this._buttons.push({
+            name,
+            buttonParamsJson: typeof params === 'string' ? params : JSON.stringify(params),
+        });
+        return this;
+    }
+    makeRow(header = '', title = '', description = '', id = '') {
+        if (this._currentSelectionIndex === -1 || this._currentSectionIndex === -1) {
+            throw new Error('You need to create a selection and a section first');
+        }
+        const buttonParams = JSON.parse(this._buttons[this._currentSelectionIndex].buttonParamsJson);
+        buttonParams.sections[this._currentSectionIndex].rows.push({ header, title, description, id });
+        this._buttons[this._currentSelectionIndex].buttonParamsJson = JSON.stringify(buttonParams);
+        return this;
+    }
+    makeSection(title = '', highlight_label = '') {
+        if (this._currentSelectionIndex === -1) {
+            throw new Error('You need to create a selection first');
+        }
+        const buttonParams = JSON.parse(this._buttons[this._currentSelectionIndex].buttonParamsJson);
+        buttonParams.sections.push({ title, highlight_label, rows: [] });
+        this._currentSectionIndex = buttonParams.sections.length - 1;
+        this._buttons[this._currentSelectionIndex].buttonParamsJson = JSON.stringify(buttonParams);
+        return this;
+    }
+    addSelection(title, options = {}) {
+        this._buttons.push({ ...options, name: 'single_select', buttonParamsJson: JSON.stringify({ title, sections: [] }) });
+        this._currentSelectionIndex = this._buttons.length - 1;
+        this._currentSectionIndex = -1;
+        return this;
+    }
+    addReply(display_text = '', id = '', options = {}) {
+        this._buttons.push({
+            name: 'quick_reply',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                id,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addCall(display_text = '', id = '', options = {}) {
+        this._buttons.push({
+            name: 'cta_call',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                id,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addReminder(display_text = '', id = '', options = {}) {
+        this._buttons.push({
+            name: 'cta_reminder',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                id,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addCancelReminder(display_text = '', id = '', options = {}) {
+        this._buttons.push({
+            name: 'cta_cancel_reminder',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                id,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addAddress(display_text = '', id = '', options = {}) {
+        this._buttons.push({
+            name: 'address_message',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                id,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addLocation(options = {}) {
+        this._buttons.push({
+            name: 'send_location',
+            buttonParamsJson: JSON.stringify(options),
+        });
+        return this;
+    }
+    addUrl(display_text = '', url = '', webview_interaction = false, options = {}) {
+        this._buttons.push({
+            ...options,
+            name: 'cta_url',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                url,
+                webview_interaction,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    addCopy(display_text = '', copy_code = '', options = {}) {
+        this._buttons.push({
+            name: 'cta_copy',
+            buttonParamsJson: JSON.stringify({
+                display_text,
+                copy_code,
+                ...options,
+            }),
+        });
+        return this;
+    }
+    setLimitedTimeOffer({ text = '', url = '', copy_code = '', expiration_time } = {}) {
+        const data = { text, url, copy_code, expiration_time };
+        __classPrivateFieldGet(_a, _a, "m", _Button_validateAgainstSchema).call(_a, _a.paramsList.limited_time_offer, data, 'limited_time_offer');
+        this._params = { ...this._params, limited_time_offer: data };
+        return this;
+    }
+    setBottomSheet({ in_thread_buttons_limit, divider_indices = [], list_title = '', button_title = '' } = {}) {
+        const data = { in_thread_buttons_limit, divider_indices, list_title, button_title };
+        __classPrivateFieldGet(_a, _a, "m", _Button_validateAgainstSchema).call(_a, _a.paramsList.bottom_sheet, data, 'bottom_sheet');
+        this._params = { ...this._params, bottom_sheet: data };
+        return this;
+    }
+    setTapTargetConfiguration({ title = '', description = '', canonical_url = '', domain = '', buttonIndex = 0 } = {}) {
+        const data = { title, description, canonical_url, domain, buttonIndex };
+        __classPrivateFieldGet(_a, _a, "m", _Button_validateAgainstSchema).call(_a, _a.paramsList.tap_target_configuration, data, 'tap_target_configuration');
+        this._params = { ...this._params, tap_target_configuration: data };
+        return this;
+    }
+    async toCard() {
+        return {
+            body: {
+                text: this._body,
+            },
+            footer: {
+                text: this._footer,
+            },
+            header: {
+                title: this._title,
+                subtitle: this._subtitle,
+                hasMediaAttachment: !!this._data,
+                ...(this._data
+                    ? await (0, messages_js_1.prepareWAMessageMedia)(this._data, { upload: __classPrivateFieldGet(this, _Button_client, "f").waUploadToServer }).catch((e) => {
+                        if (String(e).includes('Invalid media type'))
+                            return this._data;
+                        throw e;
+                    })
+                    : {}),
+            },
+            nativeFlowMessage: {
+                messageParamsJson: JSON.stringify(this._params),
+                buttons: this._buttons,
+            },
+        };
+    }
+    async build(jid, { ...options } = {}) {
+        const message = await this.toCard();
+        return (0, messages_js_1.generateWAMessageFromContent)(jid, {
+            ...this._extraPayload,
+            interactiveMessage: {
+                ...message,
+                contextInfo: this._contextInfo,
+            },
+        }, { ...options });
+    }
+    async send(jid, { ...options } = {}) {
+        const msg = await this.build(jid, options);
+        await __classPrivateFieldGet(this, _Button_client, "f").relayMessage(msg.key.remoteJid, msg.message, {
+            messageId: msg.key.id,
+            additionalNodes: [
+                {
+                    tag: 'biz',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'interactive',
+                            attrs: { type: 'native_flow', v: '1' },
+                            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+                        },
+                    ],
+                },
+            ],
+            ...options,
+        });
+        return msg;
+    }
+}
+exports.Button = Button;
+_a = Button, _Button_client = new WeakMap(), _Button_validateAgainstSchema = function _Button_validateAgainstSchema(schema, data, label) {
+    for (const [key, type] of Object.entries(schema)) {
+        if (data[key] === undefined)
+            continue;
+        const expectsArray = Array.isArray(type);
+        if (expectsArray) {
+            if (!Array.isArray(data[key]) || !data[key].every((v) => typeof v === type[0])) {
+                throw new TypeError(`${label}.${key} must be an array of ${type[0]}`);
+            }
+        }
+        else if (typeof data[key] !== type) {
+            throw new TypeError(`${label}.${key} must be a ${type}`);
+        }
+    }
+};
+Button.paramsList = {
+    limited_time_offer: {
+        text: 'string',
+        url: 'string',
+        copy_code: 'string',
+        expiration_time: 'number',
+    },
+    bottom_sheet: {
+        in_thread_buttons_limit: 'number',
+        divider_indices: ['number'],
+        list_title: 'string',
+        button_title: 'string',
+    },
+    tap_target_configuration: {
+        title: 'string',
+        description: 'string',
+        canonical_url: 'string',
+        domain: 'string',
+        buttonIndex: 'number',
+    },
+};
+class ButtonV2 extends BaseBuilder {
+    constructor(client) {
+        super();
+        _ButtonV2_client.set(this, void 0);
+        if (!client) {
+            throw new Error('Socket is required');
+        }
+        __classPrivateFieldSet(this, _ButtonV2_client, client, "f");
+        this._image;
+        this._data;
+        this._buttons = [];
+    }
+    addButton(displayText = '', buttonId = crypto_1.default.randomUUID()) {
+        this._buttons.push({
+            buttonId,
+            buttonText: { displayText },
+            type: 1,
+        });
+        return this;
+    }
+    addRawButton(obj) {
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            throw new TypeError('Buttons must be a plain object');
+        }
+        this._buttons.push(obj);
+        return this;
+    }
+    setThumbnail(path) {
+        if (!path)
+            throw new Error('Url or buffer needed');
+        this._image = path;
+        return this;
+    }
+    setMedia(obj) {
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            throw new TypeError('Media must be a plain object');
+        }
+        this._data = obj;
+        return this;
+    }
+    async build(jid, { ...options } = {}) {
+        let _thumbnail = this._image ? await Toolkit.resize(Buffer.isBuffer(this._image) ? this._image : await Toolkit.fetchBuffer(this._image, {}, { silent: true }), 300, 300) : null;
+        const msg = (0, messages_js_1.generateWAMessageFromContent)(jid, {
+            ...this._extraPayload,
+            buttonsMessage: {
+                contentText: this._body,
+                footerText: this._footer,
+                ...(this._data
+                    ? this._data
+                    : {
+                        headerType: 6,
+                        locationMessage: {
+                            degreesLatitude: 0,
+                            degreesLongitude: 0,
+                            name: this._title,
+                            address: this._subtitle,
+                            jpegThumbnail: _thumbnail,
+                        },
+                    }),
+                viewOnce: true,
+                contextInfo: this._contextInfo,
+                buttons: [...this._buttons],
+            },
+        }, { ...options });
+        return msg;
+    }
+    async send(jid, { ...options } = {}) {
+        if (this._buttons.length < 1)
+            throw new Error('ButtonV2 requires at least one button');
+        const msg = await this.build(jid, options);
+        await __classPrivateFieldGet(this, _ButtonV2_client, "f").relayMessage(msg.key.remoteJid, msg.message, {
+            messageId: msg.key.id,
+            additionalNodes: [
+                {
+                    tag: 'biz',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'interactive',
+                            attrs: { type: 'native_flow', v: '1' },
+                            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+                        },
+                    ],
+                },
+            ],
+            ...options,
+        });
+        return msg;
+    }
+}
+exports.ButtonV2 = ButtonV2;
+_ButtonV2_client = new WeakMap();
+class Carousel extends BaseBuilder {
+    constructor(client) {
+        super();
+        _Carousel_client.set(this, void 0);
+        if (!client) {
+            throw new Error('Socket is required');
+        }
+        __classPrivateFieldSet(this, _Carousel_client, client, "f");
+        this._cards = [];
+    }
+    addCard(card) {
+        const cards = Array.isArray(card) ? card : [card];
+        const baseIndex = this._cards.length;
+        for (const [index, c] of cards.entries()) {
+            if (!c?.header?.hasMediaAttachment) {
+                throw new Error(`Card [${baseIndex + index}] must include an image or video in header`);
+            }
+        }
+        this._cards.push(...cards);
+        return this;
+    }
+    build(jid, { ...options } = {}) {
+        return (0, messages_js_1.generateWAMessageFromContent)(jid, {
+            ...this._extraPayload,
+            interactiveMessage: {
+                header: {
+                    hasMediaAttachment: false,
+                },
+                body: { text: this._body },
+                footer: { text: this._footer },
+                contextInfo: this._contextInfo,
+                carouselMessage: {
+                    cards: this._cards,
+                },
+            },
+        }, { ...options });
+    }
+    async send(jid, { ...options } = {}) {
+        const msg = this.build(jid, options);
+        await __classPrivateFieldGet(this, _Carousel_client, "f").relayMessage(msg.key.remoteJid, msg.message, {
+            messageId: msg.key.id,
+            additionalNodes: [
+                {
+                    tag: 'biz',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'interactive',
+                            attrs: { type: 'native_flow', v: '1' },
+                            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+                        },
+                    ],
+                },
+            ],
+            ...options,
+        });
+        return msg;
+    }
+}
+exports.Carousel = Carousel;
+_Carousel_client = new WeakMap();
+class AIRich extends BaseBuilder {
+    constructor(client) {
+        if (!client) {
+            throw new Error('Socket is required');
+        }
+        super();
+        _AIRich_client.set(this, void 0);
+        __classPrivateFieldSet(this, _AIRich_client, client, "f");
+        this._contextInfo = {};
+        this._submessages = [];
+        this._sections = [];
+        this._richResponseSources = [];
+        // Vanz@Fix (bug 42 / inline image fallback): WA rejects rendering AIRichResponseInlineImageMetadata
+        // for third-party bots regardless of URL (confirmed empirically — Meta/WA CDN url with valid
+        // mediaKey still doesn't render, so it's a trust-chain gate, not a domain/encoding issue).
+        // Track every addInlineImage() call here so send() can fall back to a normal imageMessage.
+        this._inlineImages = [];
+    }
+    addSubmessage(submessage) {
+        const items = Array.isArray(submessage) ? submessage : [submessage];
+        for (const item of items) {
+            if (typeof item !== 'object' || item === null || Array.isArray(item)) {
+                throw new TypeError('Submessage must be a plain object or array of plain objects');
+            }
+            this._submessages.push(item);
+        }
+        return this;
+    }
+    addSection(section) {
+        const items = Array.isArray(section) ? section : [section];
+        for (const item of items) {
+            if (typeof item !== 'object' || item === null || Array.isArray(item)) {
+                throw new TypeError('Section must be a plain object or array of plain objects');
+            }
+            this._sections.push(item);
+        }
+        return this;
+    }
+    addText(text, { hyperlink = true, citation = true, latex = true } = {}) {
+        if (typeof text != 'string') {
+            throw new TypeError('Text must be a string');
+        }
+        const { text: extractedText, inline_entities } = extractIE(text, {
+            hyperlink,
+            citation,
+            latex,
+        });
+        this._submessages.push({
+            messageType: 2,
+            messageText: extractedText,
+        });
+        this._sections.push(AIRich.newLayout('Single', {
+            text: extractedText,
+            ...(inline_entities.length && {
+                inline_entities,
+            }),
+            __typename: 'GenAIMarkdownTextUXPrimitive',
+        }));
+        return this;
+    }
+    addCode(language, code) {
+        if (typeof language !== 'string' || typeof code !== 'string') {
+            throw new TypeError('Language and code must be a string');
+        }
+        const meta = AIRich.tokenizer(code, language);
+        this._submessages.push({
+            messageType: 5,
+            codeMetadata: {
+                codeLanguage: language,
+                codeBlocks: meta.codeBlock,
+            },
+        });
+        this._sections.push(AIRich.newLayout('Single', {
+            language,
+            code_blocks: meta.unified_codeBlock,
+            __typename: 'GenAICodeUXPrimitive',
+        }));
+        return this;
+    }
+    addTable(table, { hyperlink = true, citation = true, latex = true } = {}) {
+        if (!Array.isArray(table)) {
+            throw new TypeError('Table must be an array');
+        }
+        const meta = AIRich.toTableMetadata(table, { hyperlink, citation, latex });
+        this._submessages.push({
+            messageType: 4,
+            tableMetadata: {
+                title: meta.title,
+                rows: meta.rows,
+            },
+        });
+        this._sections.push(AIRich.newLayout('Single', {
+            rows: meta.unified_rows,
+            __typename: 'GenATableUXPrimitive',
+        }));
+        return this;
+    }
+    addSource(sources = []) {
+        if (!(Array.isArray(sources) && (sources.every((item) => typeof item === 'string') || sources.every((item) => Array.isArray(item) && item.every((v) => typeof v === 'string'))))) {
+            throw new TypeError('Sources must be a string array or an array of string arrays');
+        }
+        if (sources.every((item) => typeof item === 'string')) {
+            sources = [sources];
+        }
+        const source = sources.map(([icon, url, text]) => ({
+            source_type: 'THIRD_PARTY',
+            source_display_name: text ?? '',
+            source_subtitle: 'AI',
+            source_url: url ?? '',
+            favicon: {
+                url: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), icon ?? '', 'image'),
+                mime_type: 'image/jpeg',
+                width: 16,
+                height: 16,
+            },
+        }));
+        this._sections.push(AIRich.newLayout('Single', {
+            sources: source,
+            __typename: 'GenAISearchResultPrimitive',
+        }));
+        return this;
+    }
+    addReels(reelsItems = []) {
+        if (!((reelsItems && typeof reelsItems === 'object' && !Array.isArray(reelsItems)) ||
+            (Array.isArray(reelsItems) && reelsItems.every((item) => item && typeof item === 'object' && !Array.isArray(item))))) {
+            throw new TypeError('Reels items must be an object or an array of objects');
+        }
+        if (!Array.isArray(reelsItems)) {
+            reelsItems = [reelsItems];
+        }
+        const reels = reelsItems.map((item) => ({
+            ...item,
+            _avatar: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.profileIconUrl ?? item.profile_url ?? item.profile ?? '', 'image'),
+            _thumbnail: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.thumbnailUrl ?? item.thumbnail ?? '', 'image'),
+        }));
+        this._submessages.push({
+            messageType: 9,
+            contentItemsMetadata: {
+                contentType: 1,
+                itemsMetadata: reels.map((item) => ({
+                    reelItem: {
+                        title: item.username ?? '',
+                        profileIconUrl: item._avatar,
+                        thumbnailUrl: item._thumbnail,
+                        videoUrl: item.videoUrl ?? item.url ?? '',
+                    },
+                })),
+            },
+        });
+        reels.forEach((item, idx) => {
+            this._richResponseSources.push({
+                provider: 'Evernight AI',
+                thumbnailCDNURL: item._thumbnail,
+                sourceProviderURL: item.videoUrl ?? item.url ?? '',
+                sourceQuery: '',
+                faviconCDNURL: item._avatar,
+                citationNumber: idx + 1,
+                sourceTitle: item.username ?? '',
+            });
+        });
+        this._sections.push(AIRich.newLayout('HScroll', reels.map((item) => ({
+            reels_url: item.videoUrl ?? item.url ?? '',
+            thumbnail_url: item._thumbnail,
+            creator: item.username ?? item.title ?? '',
+            avatar_url: item._avatar,
+            reels_title: item.reels_title ?? item.title ?? '',
+            likes_count: item.likes_count ?? item.like ?? 0,
+            shares_count: item.shares_count ?? item.share ?? 0,
+            view_count: item.view_count ?? item.view ?? 0,
+            reel_source: item.reel_source ?? item.source ?? 'IG',
+            is_verified: !!(item.is_verified || item.verified),
+            __typename: 'GenAIReelPrimitive',
+        }))));
+        return this;
+    }
+    addImage(imageUrl, { resolveUrl = false } = {}) {
+        if (!(typeof imageUrl === 'string' || Buffer.isBuffer(imageUrl) || (Array.isArray(imageUrl) && imageUrl.every((v) => typeof v === 'string' || Buffer.isBuffer(v))))) {
+            throw new TypeError('imageUrl must be string | buffer | array of string/buffer');
+        }
+        const list = Array.isArray(imageUrl)
+            ? imageUrl.map((v) => {
+                const url = Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), v, 'image', { resolveUrl });
+                return {
+                    imagePreviewUrl: url,
+                    imageHighResUrl: url,
+                    sourceUrl: url,
+                };
+            })
+            : (() => {
+                const url = Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), imageUrl, 'image', { resolveUrl });
+                return [
+                    {
+                        imagePreviewUrl: url,
+                        imageHighResUrl: url,
+                        sourceUrl: url,
+                    },
+                ];
+            })();
+        this._submessages.push({
+            messageType: 1,
+            gridImageMetadata: {
+                gridImageUrl: {
+                    imagePreviewUrl: list[0]?.imagePreviewUrl,
+                },
+                imageUrls: list,
+            },
+        });
+        list.forEach(({ imagePreviewUrl }) => {
+            this._sections.push(AIRich.newLayout('Single', {
+                media: {
+                    url: imagePreviewUrl,
+                    mime_type: 'image/png',
+                },
+                imagine_type: 'IMAGE',
+                status: { status: 'READY' },
+                __typename: 'GenAIImaginePrimitive',
+            }));
+        });
+        return this;
+    }
+    // Vanz@Fix 15-08-26 (bug 41) --- addImage() only builds GRID_IMAGE (messageType 1).
+    // There was no helper for standalone INLINE_IMAGE (messageType 3): callers were manually
+    // pushing addSubmessage() (correct proto shape) + addSection() (WRONG shape — reused the
+    // GRID_IMAGE/GenAIImaginePrimitive section schema instead of GenAIInlineImageUXPrimitive),
+    // which broke client-side unifiedResponse rendering even though the submessage itself was fine.
+    // Mirrors RichSubMessageType.INLINE_IMAGE handling in rich-message-utils.js's toUnified().
+    addInlineImage(imageUrl, { text = '', alignment = 'center', tapLinkUrl = '', resolveUrl = false } = {}) {
+        if (!(typeof imageUrl === 'string' || Buffer.isBuffer(imageUrl) || (imageUrl && typeof imageUrl === 'object'))) {
+            throw new TypeError('imageUrl must be string | buffer | { imagePreviewUrl, imageHighResUrl, sourceUrl }');
+        }
+        const ALIGNMENT_ENUM = { leading: 0, trailing: 1, center: 2 };
+        const ALIGNMENT_NAME = ['AI_RICH_RESPONSE_IMAGE_LAYOUT_LEADING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_TRAILING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_CENTER_ALIGNED'];
+        const alignmentNum = typeof alignment === 'number' ? alignment : (ALIGNMENT_ENUM[String(alignment).toLowerCase()] ?? ALIGNMENT_ENUM.center);
+        const url = imageUrl && typeof imageUrl === 'object'
+            ? {
+                imagePreviewUrl: imageUrl.imagePreviewUrl || imageUrl.url,
+                imageHighResUrl: imageUrl.imageHighResUrl || imageUrl.url,
+                sourceUrl: imageUrl.sourceUrl || imageUrl.url,
+            }
+            : (() => {
+                const resolved = Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), imageUrl, 'image', { resolveUrl });
+                return { imagePreviewUrl: resolved, imageHighResUrl: resolved, sourceUrl: resolved };
+            })();
+        this._submessages.push({
+            messageType: 3,
+            imageMetadata: {
+                imageUrl: url,
+                imageText: text,
+                alignment: alignmentNum,
+                tapLinkUrl,
+            },
+        });
+        this._sections.push(AIRich.newLayout('Single', {
+            image_url: {
+                image_preview_url: url.imagePreviewUrl || '',
+                image_high_res_url: url.imageHighResUrl || '',
+                source_url: url.sourceUrl || '',
+            },
+            image_text: text,
+            alignment: ALIGNMENT_NAME[alignmentNum],
+            tap_link_url: tapLinkUrl,
+            __typename: 'GenAIInlineImageUXPrimitive',
+        }));
+        // Vanz@Fix (bug 42): stash for the imageMessage fallback in send()
+        this._inlineImages.push({
+            url: url.sourceUrl || url.imageHighResUrl || url.imagePreviewUrl,
+            caption: text || undefined,
+        });
+        return this;
+    }
+    // Vanz@Perf 15-08-26 --- autoFill defaults to false (arslan-baileys behavior): skips the
+    // fetch-full-video + ffmpeg-frame-extraction + duration-parse round trip per video, which
+    // was the main source of blurose's slower response time. Pass { autoFill: true } to opt
+    // back into the complete/slow path (real thumbnail + duration + file_length).
+    addVideo(videoUrl, { autoFill = false } = {}) {
+        const isObjectVideo = (v) => v && typeof v === 'object' && v.url;
+        const isValidPrimitive = typeof videoUrl === 'string' ||
+            Buffer.isBuffer(videoUrl) ||
+            isObjectVideo(videoUrl) ||
+            (Array.isArray(videoUrl) && videoUrl.every((v) => typeof v === 'string' || Buffer.isBuffer(v) || isObjectVideo(v)));
+        if (!isValidPrimitive) {
+            throw new TypeError('videoUrl must be string | buffer | object | array');
+        }
+        const items = Array.isArray(videoUrl) ? videoUrl : [videoUrl];
+        this._submessages.push({
+            messageType: 2,
+            messageText: '[ Video tidak dapat dimuat ]',
+        });
+        items.forEach((item) => {
+            const isObject = isObjectVideo(item);
+            const url = isObject ? Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.url ?? '', 'video') : Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item, 'video');
+            const bufferPromise = autoFill ? Promise.resolve(url).then((u) => Toolkit.fetchBuffer(u)) : null;
+            const file_length = isObject && item.file_length != null ? item.file_length : autoFill ? bufferPromise.then((b) => b?.length ?? 0) : 0;
+            const duration = isObject && item.duration != null
+                ? item.duration
+                : autoFill
+                    ? bufferPromise.then((b) => Toolkit.getMp4Duration(b, {
+                        silent: true,
+                    }))
+                    : 0;
+            const thumbnail = isObject && item.thumbnail
+                ? Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.thumbnail, 'image', {
+                    result: 'base64',
+                    resize: true,
+                    width: 300,
+                    height: 300,
+                })
+                : autoFill
+                    ? bufferPromise
+                        ? bufferPromise.then((b) => Toolkit.getMp4Preview(b, {
+                            time: 0,
+                            result: 'base64',
+                        }))
+                        : null
+                    : null;
+            this._sections.push(AIRich.newLayout('Single', {
+                media: {
+                    url,
+                    mime_type: isObject ? (item.mime_type ?? 'video/mp4') : 'video/mp4',
+                    file_length,
+                    duration,
+                },
+                imagine_type: 'ANIMATE',
+                status: { status: 'READY' },
+                thumbnail: {
+                    raw_media: thumbnail,
+                },
+                __typename: 'GenAIImaginePrimitive',
+            }));
+        });
+        return this;
+    }
+    addProduct(data = {}) {
+        if (!((data && typeof data === 'object' && !Array.isArray(data)) || (Array.isArray(data) && data.every((item) => item && typeof item === 'object' && !Array.isArray(item))))) {
+            throw new TypeError('Product items must be an object or an array of objects');
+        }
+        this._submessages.push({
+            messageType: 2,
+            messageText: '[ Produk tidak dapat dimuat ]',
+        });
+        const items = Array.isArray(data) ? data : [data];
+        const product = items.map((item) => ({
+            title: item.title,
+            brand: item.brand,
+            price: item.price,
+            sale_price: item.sale_price,
+            product_url: item.product_url ?? item.url,
+            image: {
+                url: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.image_url ?? item.image, 'image'),
+            },
+            additional_images: [
+                {
+                    url: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), item.icon_url ?? item.icon, 'image'),
+                },
+            ],
+            __typename: 'GenAIProductItemCardPrimitive',
+        }));
+        this._sections.push(AIRich.newLayout(Array.isArray(data) ? 'HScroll' : 'Single', Array.isArray(data) ? product : product[0]));
+        return this;
+    }
+    addPost(data = {}) {
+        if (!((data && typeof data === 'object' && !Array.isArray(data)) || (Array.isArray(data) && data.every((item) => item && typeof item === 'object' && !Array.isArray(item))))) {
+            throw new TypeError('Post items must be an object or an array of objects');
+        }
+        const posts = Array.isArray(data) ? data : [data];
+        this._submessages.push({
+            messageType: 2,
+            messageText: '[ Postingan tidak dapat dimuat ]',
+        });
+        const primitives = posts.map((p) => ({
+            title: p.title ?? '',
+            subtitle: p.subtitle ?? '',
+            username: p.username ?? '',
+            profile_picture_url: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), p.profile_picture_url ?? p.profile_url ?? p.profile ?? '', 'image'),
+            is_verified: !!(p.is_verified || p.verified),
+            thumbnail_url: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), p.thumbnail_url ?? p.thumbnail ?? '', 'image'),
+            post_caption: p.post_caption ?? p.caption ?? '',
+            likes_count: p.likes_count ?? p.like ?? 0,
+            comments_count: p.comments_count ?? p.comment ?? 0,
+            shares_count: p.shares_count ?? p.share ?? 0,
+            post_url: p.post_url ?? p.url ?? '',
+            post_deeplink: p.post_deeplink ?? p.deeplink ?? '',
+            source_app: p.source_app || p.source || 'INSTAGRAM',
+            footer_label: p.footer_label ?? p.footer ?? '',
+            footer_icon: Toolkit.resolveMedia(__classPrivateFieldGet(this, _AIRich_client, "f"), p.footer_icon ?? p.icon ?? '', 'image'),
+            is_carousel: posts.length > 1,
+            orientation: p.orientation ?? 'LANDSCAPE',
+            post_type: p.post_type ?? 'VIDEO',
+            __typename: 'GenAIPostPrimitive',
+        }));
+        this._sections.push(AIRich.newLayout('HScroll', primitives));
+        return this;
+    }
+    addTip(text) {
+        this._submessages.push({
+            messageType: 2,
+            messageText: text,
+        });
+        this._sections.push(AIRich.newLayout('Single', {
+            text,
+            __typename: 'GenAIMetadataTextPrimitive',
+        }));
+        return this;
+    }
+    addSuggest(suggestion, { scroll = true, layout } = {}) {
+        if (!(typeof suggestion === 'string' || (Array.isArray(suggestion) && suggestion.every((v) => typeof v === 'string')))) {
+            throw new TypeError('Suggestion must be a string or array of strings');
+        }
+        const suggest = Array.isArray(suggestion)
+            ? suggestion.map((text) => ({
+                prompt_text: text,
+                prompt_type: 'SUGGESTED_PROMPT',
+                __typename: 'GenAIFollowUpSuggestionPillPrimitive',
+            }))
+            : [
+                {
+                    prompt_text: suggestion,
+                    prompt_type: 'SUGGESTED_PROMPT',
+                    __typename: 'GenAIFollowUpSuggestionPillPrimitive',
+                },
+            ];
+        const type = layout ?? (suggest.length === 1 ? 'Single' : scroll ? 'HScroll' : 'ActionRow');
+        this._sections.push(AIRich.newLayout(type, type === 'Single' ? suggest[0] : suggest, { __typename: 'GenAIUnifiedResponseSection' }));
+        return this;
+    }
+    async build({ forwarded = true, notification = false, includesUnifiedResponse = true, includesSubmessages = true, quoted, quotedParticipant, ...options } = {}) {
+        const forward = forwarded
+            ? {
+                forwardingScore: 1,
+                isForwarded: true,
+                forwardedAiBotMessageInfo: { botJid: '0@bot' },
+                forwardOrigin: 4,
+            }
+            : {};
+        const notif = notification
+            ? {
+                sessionTransparencyMetadata: {
+                    disclaimerText: '~ Ahmad tumbuh kembang',
+                    hcaId: `hca_${Date.now()}`,
+                    sessionTransparencyType: 1,
+                },
+            }
+            : {};
+        const qObj = quoted
+            ? {
+                stanzaId: quoted?.key?.id || quoted?.id,
+                participant: quotedParticipant || quoted?.key?.participant || quoted?.key?.remoteJid,
+                quotedType: 0,
+                quotedMessage: typeof quoted === 'object' && quoted !== null ? (quoted.message ?? quoted) : undefined,
+            }
+            : {};
+        const sections = this._footer
+            ? [
+                ...(await waitAllPromises(this._sections)),
+                AIRich.newLayout('Single', {
+                    text: this._footer,
+                    __typename: 'GenAIMetadataTextPrimitive',
+                }),
+            ]
+            : [...(await waitAllPromises(this._sections))];
+        // Vanz@Merge 15-08-26 --- Neither blurose nor arslan sign the bot metadata with
+        // verificationMetadata (proofs/certificateChain). Backported from this project's own
+        // rich-message-utils.js botMetadataSignature/botMetadataCertificate helpers, plus a
+        // botResponseId tying the signed metadata to unifiedResponse.response_id.
+        const responseId = crypto_1.default.randomUUID();
+        return {
+            messageContextInfo: {
+                deviceListMetadata: {},
+                deviceListMetadataVersion: 2,
+                botMetadata: {
+                    messageDisclaimerText: this._title,
+                    richResponseSourcesMetadata: { sources: this._richResponseSources },
+                    botResponseId: responseId,
+                    verificationMetadata: {
+                        proofs: [
+                            {
+                                certificateChain: [(0, rich_message_utils_js_1.botMetadataCertificate)(), (0, rich_message_utils_js_1.botMetadataCertificate)(892)],
+                                version: 1,
+                                useCase: 1,
+                                signature: (0, rich_message_utils_js_1.botMetadataSignature)(),
+                            },
+                        ],
+                    },
+                    ...notif,
+                },
+            },
+            ...this._extraPayload,
+            botForwardedMessage: {
+                message: {
+                    richResponseMessage: {
+                        messageType: 1,
+                        submessages: includesSubmessages ? await waitAllPromises(this._submessages) : [],
+                        unifiedResponse: {
+                            data: includesUnifiedResponse ? Buffer.from(JSON.stringify({ response_id: responseId, sections })).toString('base64') : '',
+                        },
+                        contextInfo: {
+                            ...forward,
+                            ...qObj,
+                            ...this._contextInfo,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    // Vanz@Fix (bug 42 / inline image fallback) --- WA won't render AIRichResponseInlineImageMetadata
+    // for bot-sent messages (confirmed: even a valid WA-CDN url with mediaKey stays blank), so any
+    // image added via addInlineImage() is sent here as a normal imageMessage instead. Pass
+    // { skipImageFallback: true } to opt out and send only the (image-less-looking) rich card.
+    // Vanz@Fix (bug 42 / inline image fallback) --- WA won't render AIRichResponseInlineImageMetadata
+    // for bot-sent messages (confirmed: even a valid WA-CDN url with mediaKey stays blank), so any
+    // image added via addInlineImage() is sent here as a normal imageMessage instead. Pass
+    // { skipImageFallback: true } to opt out and send only the (image-less-looking) rich card.
+    // Vanz@Fix: don't spread relayMessage-shaped `options` into sendMessage()'s options param —
+    // the two calls expect different option shapes, so the fallback now only forwards `quoted`
+    // (the one option that clearly applies to both) instead of blindly spreading everything.
+    async send(jid, { forwarded, notification, includesUnifiedResponse, includesSubmessages, skipImageFallback = false, quoted, ...options } = {}) {
+        const msg = await this.build({ forwarded, notification, includesUnifiedResponse, includesSubmessages, quoted, ...options });
+        if (!skipImageFallback && this._inlineImages.length) {
+            for (const { url, caption } of this._inlineImages) {
+                try {
+                    await __classPrivateFieldGet(this, _AIRich_client, "f").sendMessage(jid, { image: { url }, caption }, quoted ? { quoted } : {});
+                }
+                catch (err) {
+                    // Vanz@Fix: don't let a fallback image failure block the actual rich card from sending
+                    __classPrivateFieldGet(this, _AIRich_client, "f").logger?.warn?.({ err, url }, 'inline image fallback failed, continuing with rich card');
+                }
+            }
+        }
+        return await __classPrivateFieldGet(this, _AIRich_client, "f").relayMessage(jid, msg, { ...options });
+    }
+    static tokenizer(code, lang = 'javascript') {
+        const keywordsMap = {
+            javascript: new Set([
+                'break',
+                'case',
+                'catch',
+                'continue',
+                'debugger',
+                'delete',
+                'do',
+                'else',
+                'finally',
+                'for',
+                'function',
+                'if',
+                'in',
+                'instanceof',
+                'new',
+                'return',
+                'switch',
+                'this',
+                'throw',
+                'try',
+                'typeof',
+                'var',
+                'void',
+                'while',
+                'with',
+                'true',
+                'false',
+                'null',
+                'undefined',
+                'class',
+                'const',
+                'let',
+                'super',
+                'extends',
+                'export',
+                'import',
+                'yield',
+                'static',
+                'constructor',
+                'async',
+                'await',
+                'get',
+                'set',
+            ]),
+            typescript: new Set([
+                'abstract',
+                'any',
+                'as',
+                'asserts',
+                'bigint',
+                'boolean',
+                'declare',
+                'enum',
+                'implements',
+                'infer',
+                'interface',
+                'is',
+                'keyof',
+                'module',
+                'namespace',
+                'never',
+                'readonly',
+                'require',
+                'number',
+                'object',
+                'override',
+                'private',
+                'protected',
+                'public',
+                'satisfies',
+                'string',
+                'symbol',
+                'type',
+                'unknown',
+                'using',
+                'from',
+                'break',
+                'case',
+                'catch',
+                'continue',
+                'do',
+                'else',
+                'finally',
+                'for',
+                'function',
+                'if',
+                'new',
+                'return',
+                'switch',
+                'this',
+                'throw',
+                'try',
+                'var',
+                'void',
+                'while',
+                'class',
+                'const',
+                'let',
+                'extends',
+                'import',
+                'export',
+                'async',
+                'await',
+            ]),
+            python: new Set([
+                'False',
+                'None',
+                'True',
+                'and',
+                'as',
+                'assert',
+                'async',
+                'await',
+                'break',
+                'class',
+                'continue',
+                'def',
+                'del',
+                'elif',
+                'else',
+                'except',
+                'finally',
+                'for',
+                'from',
+                'global',
+                'if',
+                'import',
+                'in',
+                'is',
+                'lambda',
+                'nonlocal',
+                'not',
+                'or',
+                'pass',
+                'raise',
+                'return',
+                'try',
+                'while',
+                'with',
+                'yield',
+            ]),
+            java: new Set([
+                'abstract',
+                'assert',
+                'boolean',
+                'break',
+                'byte',
+                'case',
+                'catch',
+                'char',
+                'class',
+                'const',
+                'continue',
+                'default',
+                'do',
+                'double',
+                'else',
+                'enum',
+                'extends',
+                'final',
+                'finally',
+                'float',
+                'for',
+                'goto',
+                'if',
+                'implements',
+                'import',
+                'instanceof',
+                'int',
+                'interface',
+                'long',
+                'native',
+                'new',
+                'package',
+                'private',
+                'protected',
+                'public',
+                'return',
+                'short',
+                'static',
+                'strictfp',
+                'super',
+                'switch',
+                'synchronized',
+                'this',
+                'throw',
+                'throws',
+                'transient',
+                'try',
+                'void',
+                'volatile',
+                'while',
+            ]),
+            golang: new Set([
+                'break',
+                'case',
+                'chan',
+                'const',
+                'continue',
+                'default',
+                'defer',
+                'else',
+                'fallthrough',
+                'for',
+                'func',
+                'go',
+                'goto',
+                'if',
+                'import',
+                'interface',
+                'map',
+                'package',
+                'range',
+                'return',
+                'select',
+                'struct',
+                'switch',
+                'type',
+                'var',
+            ]),
+            c: new Set([
+                'auto',
+                'break',
+                'case',
+                'char',
+                'const',
+                'continue',
+                'default',
+                'do',
+                'double',
+                'else',
+                'enum',
+                'extern',
+                'float',
+                'for',
+                'goto',
+                'if',
+                'int',
+                'long',
+                'register',
+                'return',
+                'short',
+                'signed',
+                'sizeof',
+                'static',
+                'struct',
+                'switch',
+                'typedef',
+                'union',
+                'unsigned',
+                'void',
+                'volatile',
+                'while',
+            ]),
+            cpp: new Set([
+                'alignas',
+                'alignof',
+                'and',
+                'auto',
+                'bool',
+                'break',
+                'case',
+                'catch',
+                'class',
+                'const',
+                'constexpr',
+                'continue',
+                'delete',
+                'do',
+                'double',
+                'else',
+                'enum',
+                'explicit',
+                'export',
+                'extern',
+                'false',
+                'float',
+                'for',
+                'friend',
+                'if',
+                'inline',
+                'int',
+                'long',
+                'mutable',
+                'namespace',
+                'new',
+                'noexcept',
+                'nullptr',
+                'operator',
+                'private',
+                'protected',
+                'public',
+                'return',
+                'short',
+                'signed',
+                'sizeof',
+                'static',
+                'struct',
+                'switch',
+                'template',
+                'this',
+                'throw',
+                'true',
+                'try',
+                'typedef',
+                'typename',
+                'union',
+                'unsigned',
+                'using',
+                'virtual',
+                'void',
+                'while',
+            ]),
+            php: new Set([
+                'abstract',
+                'and',
+                'array',
+                'as',
+                'break',
+                'callable',
+                'case',
+                'catch',
+                'class',
+                'clone',
+                'const',
+                'continue',
+                'declare',
+                'default',
+                'do',
+                'echo',
+                'else',
+                'elseif',
+                'empty',
+                'enddeclare',
+                'endfor',
+                'endforeach',
+                'endif',
+                'endswitch',
+                'endwhile',
+                'extends',
+                'final',
+                'finally',
+                'fn',
+                'for',
+                'foreach',
+                'function',
+                'global',
+                'goto',
+                'if',
+                'implements',
+                'include',
+                'include_once',
+                'instanceof',
+                'interface',
+                'match',
+                'namespace',
+                'new',
+                'null',
+                'or',
+                'private',
+                'protected',
+                'public',
+                'require',
+                'require_once',
+                'return',
+                'static',
+                'switch',
+                'throw',
+                'trait',
+                'try',
+                'use',
+                'var',
+                'while',
+                'yield',
+            ]),
+            rust: new Set([
+                'as',
+                'break',
+                'const',
+                'continue',
+                'crate',
+                'else',
+                'enum',
+                'extern',
+                'false',
+                'fn',
+                'for',
+                'if',
+                'impl',
+                'in',
+                'let',
+                'loop',
+                'match',
+                'mod',
+                'move',
+                'mut',
+                'pub',
+                'ref',
+                'return',
+                'self',
+                'Self',
+                'static',
+                'struct',
+                'super',
+                'trait',
+                'true',
+                'type',
+                'unsafe',
+                'use',
+                'where',
+                'while',
+            ]),
+            html: new Set([
+                'html',
+                'head',
+                'body',
+                'div',
+                'span',
+                'p',
+                'a',
+                'img',
+                'video',
+                'audio',
+                'script',
+                'style',
+                'link',
+                'meta',
+                'form',
+                'input',
+                'button',
+                'table',
+                'tr',
+                'td',
+                'th',
+                'ul',
+                'ol',
+                'li',
+                'section',
+                'article',
+                'header',
+                'footer',
+                'nav',
+                'main',
+            ]),
+            bash: new Set([
+                'if',
+                'then',
+                'else',
+                'elif',
+                'fi',
+                'for',
+                'while',
+                'do',
+                'done',
+                'case',
+                'esac',
+                'function',
+                'in',
+                'select',
+                'until',
+                'break',
+                'continue',
+                'return',
+                'export',
+                'readonly',
+                'local',
+                'declare',
+            ]),
+            markdown: new Set(['#', '##', '###', '####', '#####', '######']),
+        };
+        if (!lang || lang === 'txt' || lang === 'text' || lang === 'plaintext') {
+            return {
+                codeBlock: [
+                    {
+                        codeContent: code,
+                        highlightType: 0,
+                    },
+                ],
+                unified_codeBlock: [
+                    {
+                        content: code,
+                        type: 'DEFAULT',
+                    },
+                ],
+            };
+        }
+        const TYPE_MAP = {
+            0: 'DEFAULT',
+            1: 'KEYWORD',
+            2: 'METHOD',
+            3: 'STR',
+            4: 'NUMBER',
+            5: 'COMMENT',
+        };
+        const keywords = keywordsMap[lang.toLowerCase()] || new Set();
+        const tokens = [];
+        let i = 0;
+        const push = (content, type) => {
+            if (!content)
+                return;
+            const last = tokens[tokens.length - 1];
+            if (last && last.highlightType === type) {
+                last.codeContent += content;
+            }
+            else {
+                tokens.push({
+                    codeContent: content,
+                    highlightType: type,
+                });
+            }
+        };
+        const isIdentifier = (char) => {
+            switch (lang.toLowerCase()) {
+                case 'css':
+                    return /[a-zA-Z0-9_$-]/.test(char);
+                case 'html':
+                    return /[a-zA-Z0-9_$:-]/.test(char);
+                default:
+                    return /[a-zA-Z0-9_$]/.test(char);
+            }
+        };
+        while (i < code.length) {
+            const c = code[i];
+            if (/\s/.test(c)) {
+                let s = i;
+                while (i < code.length && /\s/.test(code[i])) {
+                    i++;
+                }
+                push(code.slice(s, i), 0);
+                continue;
+            }
+            if ((c === '/' && code[i + 1] === '/') || (c === '#' && ['python', 'bash'].includes(lang))) {
+                let s = i;
+                while (i < code.length && code[i] !== '\n') {
+                    i++;
+                }
+                push(code.slice(s, i), 5);
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                let s = i;
+                const q = c;
+                i++;
+                while (i < code.length) {
+                    if (code[i] === '\\' && i + 1 < code.length) {
+                        i += 2;
+                    }
+                    else if (code[i] === q) {
+                        i++;
+                        break;
+                    }
+                    else {
+                        i++;
+                    }
+                }
+                push(code.slice(s, i), 3);
+                continue;
+            }
+            if (/[0-9]/.test(c)) {
+                let s = i;
+                while (i < code.length && /[0-9._]/.test(code[i])) {
+                    i++;
+                }
+                push(code.slice(s, i), 4);
+                continue;
+            }
+            if (/[a-zA-Z_$]/.test(c)) {
+                let s = i;
+                while (i < code.length && isIdentifier(code[i])) {
+                    i++;
+                }
+                const word = code.slice(s, i);
+                let type = 0;
+                if (keywords.has(word)) {
+                    type = 1;
+                }
+                else if (lang === 'css') {
+                    let j = i;
+                    while (j < code.length && /\s/.test(code[j])) {
+                        j++;
+                    }
+                    if (code[j] === ':') {
+                        type = 1;
+                    }
+                }
+                else if (lang === 'html') {
+                    let p = s - 1;
+                    while (p >= 0 && /\s/.test(code[p])) {
+                        p--;
+                    }
+                    if (code[p] === '<' || (code[p] === '/' && code[p - 1] === '<')) {
+                        type = 1;
+                    }
+                }
+                if (type === 0) {
+                    let j = i;
+                    while (j < code.length && /\s/.test(code[j])) {
+                        j++;
+                    }
+                    if (code[j] === '(') {
+                        type = 2;
+                    }
+                }
+                push(word, type);
+                continue;
+            }
+            push(c, 0);
+            i++;
+        }
+        return {
+            codeBlock: tokens,
+            unified_codeBlock: tokens.map((t) => ({
+                content: t.codeContent,
+                type: TYPE_MAP[t.highlightType],
+            })),
+        };
+    }
+    static toTableMetadata(arr, { hyperlink = true, citation = true, latex = true } = {}) {
+        if (!Array.isArray(arr) || !arr.every((row) => Array.isArray(row) && row.every((cell) => typeof cell === 'string'))) {
+            throw new TypeError('Table must be a nested array of strings');
+        }
+        const [header, ...rows] = arr;
+        const maxLen = Math.max(header.length, ...rows.map((r) => r.length));
+        const normalize = (r) => [...r, ...Array(maxLen - r.length).fill('')];
+        const unified_rows = [
+            {
+                is_header: true,
+                cells: normalize(header),
+            },
+            ...rows.map((r) => ({
+                is_header: false,
+                cells: normalize(r),
+            })),
+        ].map((row) => {
+            const markdown_cells = row.cells.map((cell) => {
+                const extracted = extractIE(cell, { hyperlink, citation, latex });
+                return {
+                    text: extracted.text,
+                    ...(extracted.inline_entities.length ? { inline_entities: extracted.inline_entities } : {}),
+                };
+            });
+            return {
+                ...row,
+                ...(markdown_cells.some((c) => c.inline_entities?.length) ? { markdown_cells } : {}),
+            };
+        });
+        const rowsMeta = unified_rows.map((r) => ({
+            items: r.cells,
+            ...(r.is_header ? { isHeading: true } : {}),
+        }));
+        return {
+            title: '',
+            rows: rowsMeta,
+            unified_rows,
+        };
+    }
+    static newLayout(name, data, extra = {}) {
+        return {
+            ...extra,
+            view_model: {
+                [Array.isArray(data) ? 'primitives' : 'primitive']: data,
+                __typename: `GenAI${name}LayoutViewModel`,
+            },
+        };
+    }
+}
+exports.AIRich = AIRich;
+_AIRich_client = new WeakMap();