@risacakep/risayap 0.0.0-stage → 7.0.0-rc25.7

package/lib/extensions/clarissa-MessageBuilder.js

@@ -0,0 +1,3257 @@
+/*
+⌬═════════════════════⌬
+┇
+┇   ▬▬▬▬▬▬▬▬ ஐஐ ▬▬▬▬▬▬▬▬
+┇    ----- 🥳 𝗪𝗘𝗟𝗖𝗢𝗠𝗘 𝗕𝗥𝗢𝗞 🙌 -----
+┇   ▬▬▬▬▬▬▬▬ ஐஐ ▬▬▬▬▬▬▬▬
+┇
+┇
+┇     █▀█ █ █▀█ █▀█   ▄▀█ █
+┇     █  █ █ █▀▄ █▄█   █▀█ █      
+┇     ▀█  --𝗤--𝗜--𝗥--𝗢------𝗔--𝗜----
+┇
+┇  ❏ ───────────────── ❏
+┇      ✧･ﾟ 💬  𝗜𝗡𝗙𝗢𝗥𝗠𝗔𝗧𝗜𝗢𝗡  💬  ﾟ･✧
+┇  ❏ ───────────────── ❏
+┇   › ୨୧ Developer  : Clarissa 
+┇   › ୨୧ Website   : clarissa.my.id 
+┇   › ୨୧ WhatsApp : wa.me/556184127506 
+┇
+┇  ✦ ───────────────── ✦
+┇    ✧･ﾟ ⛔  𝗗𝗜𝗟𝗔𝗥𝗔𝗡𝗚 𝗞𝗘𝗥𝗔𝗦  ⛔ ﾟ･✧
+┇  ✦ ───────────────── ✦
+┇   › ✎ Dilarang Hapus Creadit SC  
+┇   › ✎ Dilarang Jual-Beli Script Ini  
+┇   › ✎ Dilarang Ngaku Sebagai Dev Clarissa  
+┇   › ✎ Jangan Ganti Baileys ya Brok!!  
+┇
+┇  ♡ ───────────────── ♡
+┇      ✧･ﾟ 🌸  𝗜𝗭𝗜𝗡 & 𝗦𝗬𝗔𝗥𝗔𝗧  🌸 ﾟ･✧
+┇  ♡ ───────────────── ♡
+┇   › ○ Bebas Kembangin dan Recode SC  
+┇   › ○ Bebas Modif dan Tambah Fitur
+┇   › ○ Bebas Share Ke Teman / Group  
+┇   › ○ Wajib Izin & Cantumin Creadit  
+┇   › ○ Hargai Karya Orang Anjing!!!!  
+┇   
+┇  ⚠ ───────────────── ⚠
+┇  ✧･ﾟ 📢  𝗖𝗔𝗧𝗔𝗧𝗔𝗡 & 𝗟𝗔𝗣𝗢𝗥𝗔𝗡  📢 ﾟ･✧
+┇  ⚠ ───────────────── ⚠
+┇   › Jika menemukan yang melanggar
+┇   › aturan di atas, segera laporkan
+┇   › via WhatsApp yang tertera
+┇
+┇   › sertakan bukti Screenshot / Link
+┇   › agar cepat kami tindak lanjuti!!
+┇  ╺╺╺╺╺╺╺╺╺╺╺╺╺╺╺✧˖°.
+┇
+┇  ║▌│█║▌│ █║▌│█│║▌
+┇     ♡  𝗖𝗟𝗔𝗥𝗜𝗦𝗦𝗔 - 𝗔𝗜 | 𝟮𝟬𝟮𝟲  ♡
+┇
+⌬═════════════════════⌬
+*/
+
+'use strict';
+
+const VERSION = '4.7';
+
+import { generateWAMessageFromContent, prepareWAMessageMedia, generateMessageIDV2 } from '@risacakep/risayap';
+import crypto from 'crypto';
+import sharp from 'sharp';
+import ffmpeg from 'fluent-ffmpeg';
+import { PassThrough, Readable } from 'stream';
+
+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 AIRichError extends Error {
+	constructor(message, code, meta = {}) {
+		super(message);
+		this.name = 'AIRichError';
+		this.code = code;
+		Object.assign(this, meta);
+	}
+}
+
+class ItemNotFoundError extends AIRichError {
+	constructor(id, availableIds = []) {
+		super(`Item id "${id}" not found${availableIds.length ? ` (available: ${availableIds.join(', ')})` : ' (no items have an id yet)'}`, 'ITEM_NOT_FOUND', { id, availableIds });
+		this.name = 'ItemNotFoundError';
+	}
+}
+
+class DuplicateIdError extends AIRichError {
+	constructor(id) {
+		super(`Item id "${id}" already exists`, 'DUPLICATE_ID', { id });
+		this.name = 'DuplicateIdError';
+	}
+}
+
+class InvalidTargetError extends AIRichError {
+	constructor(message, meta = {}) {
+		super(message, 'INVALID_TARGET', meta);
+		this.name = 'InvalidTargetError';
+	}
+}
+
+class ContentValidationError extends AIRichError {
+	constructor(message, meta = {}) {
+		super(message, 'CONTENT_VALIDATION', meta);
+		this.name = 'ContentValidationError';
+	}
+}
+
+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') {
+		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 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 Readable({ read() {} });
+				inputStream.push(videoBuffer);
+				inputStream.push(null);
+
+				const outputStream = new 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 = time ?? Math.min(Toolkit.getMp4Duration(videoBuffer) * 0.2, 10);
+
+				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 (err) {
+				return fail(err);
+			}
+		});
+	}
+
+	static stringifyEscaped(obj) {
+		return JSON.stringify(obj).replace(/[\u007f-\uffff]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'));
+	}
+}
+
+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 {
+	#client;
+
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+		this.#client = client;
+
+		this._buttons = [];
+		this._data;
+		this._currentSelectionIndex = -1;
+		this._currentSectionIndex = -1;
+		this._params = {};
+	}
+
+	loadFrom(msg) {
+		if (!msg) throw new Error('interactiveMessage needed');
+		if (!msg.interactiveMessage) throw new Error('interactiveMessage not found');
+
+		const { interactiveMessage, ...extraPayload } = msg;
+		const iM = interactiveMessage;
+		const header = iM.header || {};
+		const nativeFlow = iM.nativeFlowMessage || {};
+
+		this._title = header.title || '';
+		this._subtitle = header.subtitle || '';
+		this._body = iM.body?.text || '';
+		this._footer = iM.footer?.text || '';
+		this._contextInfo = iM.contextInfo || {};
+		this._extraPayload = extraPayload;
+
+		this._buttons = Array.isArray(nativeFlow.buttons)
+			? nativeFlow.buttons.map((button) => ({
+					...button,
+					buttonParamsJson: typeof button.buttonParamsJson === 'string' ? button.buttonParamsJson : JSON.stringify(button.buttonParamsJson || {}),
+				}))
+			: [];
+
+		this._data = header.imageMessage
+			? { imageMessage: header.imageMessage }
+			: header.videoMessage
+				? { videoMessage: header.videoMessage }
+				: header.documentMessage
+					? { documentMessage: header.documentMessage }
+					: header.productMessage
+						? { productMessage: header.productMessage }
+						: undefined;
+
+		this._params = {};
+
+		if (typeof nativeFlow.messageParamsJson === 'string') {
+			try {
+				this._params = JSON.parse(nativeFlow.messageParamsJson || '{}');
+			} catch {
+				this._params = {};
+			}
+		} else if (nativeFlow.messageParamsJson && typeof nativeFlow.messageParamsJson === 'object') {
+			this._params = { ...nativeFlow.messageParamsJson };
+		}
+
+		this._currentSelectionIndex = this._buttons.findLastIndex((button) => button.name === 'single_select');
+
+		this._currentSectionIndex = -1;
+
+		if (this._currentSelectionIndex !== -1) {
+			try {
+				const button = this._buttons[this._currentSelectionIndex];
+				const params = JSON.parse(button.buttonParamsJson || '{}');
+
+				if (Array.isArray(params.sections) && params.sections.length) {
+					this._currentSectionIndex = params.sections.length - 1;
+				}
+			} catch {
+				this._currentSelectionIndex = -1;
+				this._currentSectionIndex = -1;
+			}
+		}
+
+		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({ name: 'single_select', buttonParamsJson: JSON.stringify({ title, sections: [], ...options }) });
+		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;
+	}
+
+	static 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',
+		},
+	};
+
+	async toCard() {
+		return {
+			body: {
+				text: this._body,
+			},
+			footer: {
+				text: this._footer,
+			},
+			header: {
+				title: this._title,
+				subtitle: this._subtitle,
+				hasMediaAttachment: !!this._data,
+				...(this._data
+					? await prepareWAMessageMedia(this._data, { upload: this.#client.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, { messageId, ...options } = {}) {
+		const message = await this.toCard();
+
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				interactiveMessage: {
+					...message,
+					contextInfo: this._contextInfo,
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+	}
+
+	async send(jid, { messageId, additionalNodes = [], ...options } = {}) {
+		const msg = await this.build(jid, { messageId, ...options });
+
+		await this.#client.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' } }],
+						},
+					],
+				},
+				...additionalNodes,
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+class ButtonV2 extends BaseBuilder {
+	#client;
+
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._image;
+		this._data;
+		this._buttons = [];
+	}
+
+	loadFrom(msg) {
+		if (!msg) throw new Error('buttonsMessage needed');
+		if (!msg.buttonsMessage) throw new Error('buttonsMessage not found');
+
+		const { buttonsMessage, ...extraPayload } = msg;
+		const bM = buttonsMessage;
+		const location = bM.locationMessage || {};
+
+		this._title = location.name || '';
+		this._subtitle = location.address || '';
+		this._body = bM.contentText || '';
+		this._footer = bM.footerText || '';
+		this._contextInfo = bM.contextInfo || {};
+		this._extraPayload = extraPayload;
+
+		this._buttons = Array.isArray(bM.buttons)
+			? bM.buttons.map((button) => ({
+					...button,
+					...(button.nativeFlowInfo
+						? {
+								nativeFlowInfo: {
+									...button.nativeFlowInfo,
+									paramsJson: typeof button.nativeFlowInfo.paramsJson === 'string' ? button.nativeFlowInfo.paramsJson : JSON.stringify(button.nativeFlowInfo.paramsJson || {}),
+								},
+							}
+						: {}),
+				}))
+			: [];
+
+		this._image = location.jpegThumbnail || undefined;
+
+		if (!this._image && bM.locationMessage) {
+			this._image = undefined;
+		}
+
+		if (!bM.locationMessage && bM.headerType === 6) {
+			this._image = undefined;
+		}
+
+		this._data = Object.keys(bM).reduce((data, key) => {
+			if (!['contentText', 'footerText', 'contextInfo', 'buttons', 'headerType', 'locationMessage', 'viewOnce'].includes(key)) {
+				data[key] = bM[key];
+			}
+			return data;
+		}, {});
+
+		if (!Object.keys(this._data).length) {
+			this._data = undefined;
+		}
+
+		return this;
+	}
+
+	addButton(displayText = '', buttonId = crypto.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;
+	}
+
+	setRawThumbnail(thumbnail) {
+		if (!thumbnail) throw new Error('Thumbnail needed');
+		this._image = { base64: thumbnail, is_raw: true };
+		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, { messageId, ...options } = {}) {
+		const _thumbnail = this._image?.is_raw
+			? this._image.base64
+			: this._image
+				? await Toolkit.resize(Buffer.isBuffer(this._image) ? this._image : await Toolkit.fetchBuffer(this._image, {}, { silent: true }), 300, 300)
+				: null;
+		const msg = 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],
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+		return msg;
+	}
+
+	async send(jid, { messageId, additionalNodes = [], ...options } = {}) {
+		if (this._buttons.length < 1) throw new Error('ButtonV2 requires at least one button');
+		const msg = await this.build(jid, { messageId, ...options });
+
+		await this.#client.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' } }],
+						},
+					],
+				},
+				...additionalNodes,
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+class Carousel extends BaseBuilder {
+	#client;
+
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._cards = [];
+	}
+
+	loadFrom(msg) {
+		if (!msg) throw new Error('interactiveMessage needed');
+		if (!msg.interactiveMessage) throw new Error('interactiveMessage not found');
+
+		const { interactiveMessage, ...extraPayload } = msg;
+		const iM = interactiveMessage;
+		const carousel = iM.carouselMessage || {};
+
+		this._body = iM.body?.text || '';
+		this._footer = iM.footer?.text || '';
+		this._contextInfo = iM.contextInfo || {};
+		this._extraPayload = extraPayload;
+
+		this._cards = Array.isArray(carousel.cards)
+			? carousel.cards.map((card) => ({
+					...card,
+					header: {
+						...(card.header || {}),
+						hasMediaAttachment: !!card.header?.hasMediaAttachment,
+						...(card.header?.imageMessage ? { imageMessage: card.header.imageMessage } : {}),
+						...(card.header?.videoMessage ? { videoMessage: card.header.videoMessage } : {}),
+					},
+					body: {
+						text: card.body?.text || '',
+					},
+					footer: {
+						text: card.footer?.text || '',
+					},
+					nativeFlowMessage: {
+						...(card.nativeFlowMessage || {}),
+						buttons: Array.isArray(card.nativeFlowMessage?.buttons)
+							? card.nativeFlowMessage.buttons.map((button) => ({
+									...button,
+									buttonParamsJson: typeof button.buttonParamsJson === 'string' ? button.buttonParamsJson : JSON.stringify(button.buttonParamsJson || {}),
+								}))
+							: [],
+						messageParamsJson:
+							typeof card.nativeFlowMessage?.messageParamsJson === 'string' ? card.nativeFlowMessage.messageParamsJson : JSON.stringify(card.nativeFlowMessage?.messageParamsJson || {}),
+					},
+				}))
+			: [];
+
+		return this;
+	}
+
+	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, { messageId, ...options } = {}) {
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				interactiveMessage: {
+					header: {
+						hasMediaAttachment: false,
+					},
+					body: { text: this._body },
+					footer: { text: this._footer },
+					contextInfo: this._contextInfo,
+					carouselMessage: {
+						cards: this._cards,
+					},
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+	}
+
+	async send(jid, { messageId, additionalNodes = [], ...options } = {}) {
+		const msg = this.build(jid, { messageId, ...options });
+
+		await this.#client.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' } }],
+						},
+					],
+				},
+				...additionalNodes,
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+class AIRich extends BaseBuilder {
+	#client;
+
+	constructor(client, { dynamic = true, unsupportedTypeAlert = true } = {}) {
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		super();
+		this.#client = client;
+		this._contextInfo = {};
+		this._nodes = [];
+		this._idIndex = new Map();
+		this._unsupportedTypeAlert = !!unsupportedTypeAlert;
+		this._dynamic = !!dynamic;
+		this._responseId = crypto.randomUUID();
+		this._botResponseId = crypto.randomUUID();
+		this._lastMessageKey = null;
+	}
+
+	loadFrom(msg) {
+		if (!msg) throw new Error('AI Rich message needed');
+
+		const message = msg.message ?? msg;
+
+		let richResponseMessage = message?.botForwardedMessage?.message?.richResponseMessage;
+
+		if (!richResponseMessage) {
+			richResponseMessage = message?.botForwardedMessage?.richResponseMessage;
+		}
+
+		if (!richResponseMessage) {
+			richResponseMessage = message?.richResponseMessage;
+		}
+
+		if (!richResponseMessage) {
+			throw new Error('richResponseMessage not found');
+		}
+
+		const messageContextInfo = message?.messageContextInfo ?? {};
+		const botMetadata = messageContextInfo?.botMetadata ?? {};
+
+		this._title = botMetadata?.messageDisclaimerText ?? '';
+
+		this._contextInfo = structuredClone(richResponseMessage?.contextInfo ?? {});
+
+		const loadedSubmessages = Array.isArray(richResponseMessage?.submessages) ? structuredClone(richResponseMessage.submessages) : [];
+
+		let loadedSections = [];
+
+		const unifiedData = richResponseMessage?.unifiedResponse?.data;
+
+		if (unifiedData) {
+			try {
+				const decoded = Buffer.from(unifiedData, 'base64').toString('utf8');
+				const unifiedResponse = JSON.parse(decoded);
+
+				if (Array.isArray(unifiedResponse?.sections)) {
+					loadedSections = structuredClone(unifiedResponse.sections);
+				}
+			} catch {}
+		}
+
+		this._nodes = [];
+		this._idIndex = new Map();
+
+		const maxLength = Math.max(loadedSections.length, loadedSubmessages.length);
+
+		for (let i = 0; i < maxLength; i++) {
+			this._nodes.push({
+				id: null,
+				section: loadedSections[i] ?? null,
+				submessage: loadedSubmessages[i] ?? null,
+			});
+		}
+
+		this._extraPayload = {};
+
+		for (const [key, value] of Object.entries(message)) {
+			if (key !== 'messageContextInfo' && key !== 'botForwardedMessage' && key !== 'richResponseMessage') {
+				this._extraPayload[key] = structuredClone(value);
+			}
+		}
+
+		return this;
+	}
+
+	setResponseId(id) {
+		if (typeof id !== 'string') {
+			throw new TypeError('ID must be a string');
+		}
+		this._responseId = id;
+
+		return this;
+	}
+
+	refreshResponseId() {
+		this._responseId = crypto.randomUUID();
+
+		return this;
+	}
+
+	setBotResponseId(id) {
+		if (typeof id !== 'string') {
+			throw new TypeError('ID must be a string');
+		}
+		this._botResponseId = id;
+
+		return this;
+	}
+
+	refreshBotResponseId() {
+		this._botResponseId = crypto.randomUUID();
+
+		return this;
+	}
+
+	createAlert(type) {
+		if (this._unsupportedTypeAlert) {
+			return {
+				messageType: 2,
+				messageText: `[ UNSUPPORTED_TYPE - ${type}]`,
+			};
+		}
+
+		return undefined;
+	}
+
+	addText(text, { hyperlink = true, citation = true, latex = true, id, replace, insertAt } = {}) {
+		if (typeof text !== 'string') {
+			throw new TypeError('Text must be a string');
+		}
+
+		const { text: extractedText, inline_entities } = extractIE(text, {
+			hyperlink,
+			citation,
+			latex,
+		});
+
+		const section = AIRich.newLayout('Single', {
+			text: extractedText,
+			...(inline_entities.length && { inline_entities }),
+			__typename: 'GenAIMarkdownTextUXPrimitive',
+		});
+
+		const submessages = [
+			{
+				messageType: 2,
+				messageText: text,
+			},
+		].filter(Boolean);
+
+		return this._addContent(section, submessages, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addFOAText(text, { id, replace, insertAt } = {}) {
+		if (typeof text !== 'string') {
+			throw new TypeError('Text must be a string');
+		}
+
+		const section = AIRich.newLayout('Single', {
+			text,
+			__typename: 'FOATextPrimitive',
+		});
+
+		const submessages = [
+			{
+				messageType: 2,
+				messageText: text,
+			},
+		];
+
+		return this._addContent(section, submessages, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addCode(language, code, { id, replace, insertAt } = {}) {
+		if (typeof language !== 'string' || typeof code !== 'string') {
+			throw new TypeError('Language and code must be a string');
+		}
+
+		const meta = AIRich.tokenizer(code, language);
+
+		const section = AIRich.newLayout('Single', {
+			language,
+			code_blocks: meta.unified_codeBlock,
+			__typename: 'GenAICodeUXPrimitive',
+		});
+
+		const submessages = [
+			{
+				messageType: 5,
+				codeMetadata: {
+					codeLanguage: language,
+					codeBlocks: meta.codeBlock,
+				},
+			},
+		];
+
+		return this._addContent(section, submessages, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addTable(table, { hyperlink = true, citation = true, latex = true, id, replace, insertAt } = {}) {
+		if (!Array.isArray(table)) {
+			throw new TypeError('Table must be an array');
+		}
+
+		const meta = AIRich.toTableMetadata(table, {
+			hyperlink,
+			citation,
+			latex,
+		});
+
+		const section = AIRich.newLayout('Single', {
+			rows: meta.unified_rows,
+			__typename: 'GenATableUXPrimitive',
+		});
+
+		const submessages = [
+			{
+				messageType: 4,
+				tableMetadata: {
+					title: meta.title,
+					rows: meta.rows,
+				},
+			},
+		];
+
+		return this._addContent(section, submessages, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addSource(sources = [], { id, replace, insertAt } = {}) {
+		if (!Array.isArray(sources)) {
+			throw new TypeError('Sources must be an array of strings, arrays, or objects');
+		}
+
+		const isStringArray = sources.every((item) => typeof item === 'string');
+
+		const isArrayFormat = sources.every((item) => Array.isArray(item) && item.every((value) => typeof value === 'string'));
+
+		const isObjectFormat = sources.every((item) => item && typeof item === 'object' && !Array.isArray(item));
+
+		if (!isStringArray && !isArrayFormat && !isObjectFormat) {
+			throw new TypeError('Sources must be a string array, array of string arrays, or array of objects');
+		}
+
+		if (isStringArray) {
+			sources = [sources];
+		}
+
+		const normalizedSources = sources.map((source) => {
+			if (Array.isArray(source)) {
+				const [icon, url, title, subtitle] = source;
+
+				return {
+					icon,
+					url,
+					title,
+					subtitle,
+				};
+			}
+
+			return {
+				icon: source.favicon ?? source.icon ?? '',
+				url: source.url ?? '',
+				title: source.title ?? '',
+				subtitle: source.subtitle ?? '',
+			};
+		});
+
+		const source = normalizedSources.map(({ icon, url, title, subtitle }) => ({
+			source_type: 'THIRD_PARTY',
+			source_display_name: title,
+			source_subtitle: subtitle,
+			source_url: url,
+			favicon: {
+				url: Toolkit.resolveMedia(this.#client, icon, 'image'),
+				mime_type: 'image/jpeg',
+				width: 16,
+				height: 16,
+			},
+		}));
+
+		const submessage = this.createAlert('GenAISearchResultPrimitive');
+
+		const section = AIRich.newLayout('Single', {
+			sources: source,
+			__typename: 'GenAISearchResultPrimitive',
+		});
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addReels(reelsItems = [], { id, replace, insertAt } = {}) {
+		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');
+		}
+
+		const items = Array.isArray(reelsItems) ? reelsItems : [reelsItems];
+
+		const reels = items.map((item) => ({
+			...item,
+			_avatar: Toolkit.resolveMedia(this.#client, item.profileIconUrl ?? item.profile_url ?? item.profile ?? '', 'image'),
+			_thumbnail: Toolkit.resolveMedia(this.#client, item.thumbnailUrl ?? item.thumbnail ?? '', 'image'),
+		}));
+
+		const section = 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',
+			}))
+		);
+
+		const submessages = [
+			{
+				messageType: 9,
+				contentItemsMetadata: {
+					contentType: 1,
+					itemsMetadata: reels.map((item) => ({
+						reelItem: {
+							title: item.username ?? '',
+							profileIconUrl: item._avatar,
+							thumbnailUrl: item._thumbnail,
+							videoUrl: item.videoUrl ?? item.url ?? '',
+						},
+					})),
+				},
+			},
+		];
+
+		return this._addContent(section, submessages, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addImage(imageUrl, { width, height, status = 'READY', update_text, resolveUrl = false, id, replace, insertAt } = {}) {
+		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(this.#client, v, 'image', { resolveUrl });
+
+					return {
+						imagePreviewUrl: url,
+						imageHighResUrl: url,
+						sourceUrl: url,
+					};
+				})
+			: (() => {
+					const url = Toolkit.resolveMedia(this.#client, imageUrl, 'image', { resolveUrl });
+
+					return [
+						{
+							imagePreviewUrl: url,
+							imageHighResUrl: url,
+							sourceUrl: url,
+						},
+					];
+				})();
+
+		const sections = list.map(({ imagePreviewUrl }) =>
+			AIRich.newLayout('Single', {
+				media: {
+					url: imagePreviewUrl,
+					mime_type: 'image/png',
+					width,
+					height,
+				},
+				imagine_type: 'IMAGE',
+				status: {
+					status,
+					update_text,
+				},
+				__typename: 'GenAIImaginePrimitive',
+			})
+		);
+
+		const submessage = {
+			messageType: 1,
+			gridImageMetadata: {
+				gridImageUrl: {
+					imagePreviewUrl: list[0]?.imagePreviewUrl,
+				},
+				imageUrls: list,
+			},
+		};
+
+		if (id && sections.length !== 1) {
+			throw new Error('Cannot assign one id to multiple image sections');
+		}
+
+		return this._addContent(sections, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addVideo(videoUrl, { autoFill = true, status = 'READY', estimatedTime, id, replace, insertAt } = {}) {
+		const isObjectVideo = (v) => v && typeof v === 'object' && !Array.isArray(v) && 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];
+
+		const alert = this.createAlert('GenAIImaginePrimitive (ANIMATE)');
+
+		const sections = [];
+		const submessages = [];
+
+		for (const item of items) {
+			const isObject = isObjectVideo(item);
+
+			const url = isObject ? Toolkit.resolveMedia(this.#client, item.url ?? '', 'video') : Toolkit.resolveMedia(this.#client, 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(this.#client, item.thumbnail, 'image', {
+							result: 'base64',
+							resize: true,
+							width: 300,
+							height: 300,
+						})
+					: autoFill
+						? bufferPromise?.then((b) =>
+								Toolkit.getMp4Preview(b, {
+									time: 0,
+									result: 'base64',
+								})
+							)
+						: null;
+
+			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,
+						estimated_completion_time: estimatedTime != null ? Math.floor((Date.now() + estimatedTime) / 1000) : undefined,
+					},
+					thumbnail: {
+						raw_media: thumbnail,
+					},
+					__typename: 'GenAIImaginePrimitive',
+				})
+			);
+		}
+
+		if (alert !== undefined) {
+			submessages.push(alert);
+		}
+
+		if (submessages.length > 1) {
+			throw new Error('Video content can only have one submessage');
+		}
+
+		return this._addContent(sections, submessages[0], {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addProduct(data = {}, { id, replace, insertAt } = {}) {
+		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');
+		}
+
+		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(this.#client, item.image_url ?? item.image, 'image'),
+			},
+			additional_images: [
+				{
+					url: Toolkit.resolveMedia(this.#client, item.icon_url ?? item.icon, 'image'),
+				},
+			],
+			__typename: 'GenAIProductItemCardPrimitive',
+		}));
+
+		const section = AIRich.newLayout(Array.isArray(data) ? 'HScroll' : 'Single', Array.isArray(data) ? product : product[0]);
+
+		const submessage = this.createAlert('GenAIProductItemCardPrimitive');
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addPost(data = {}, { id, replace, insertAt } = {}) {
+		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];
+
+		const primitives = posts.map((p) => ({
+			title: p.title ?? '',
+			subtitle: p.subtitle ?? '',
+			username: p.username ?? '',
+			profile_picture_url: Toolkit.resolveMedia(this.#client, p.profile_picture_url ?? p.profile_url ?? p.profile ?? '', 'image'),
+			is_verified: !!(p.is_verified || p.verified),
+			thumbnail_url: Toolkit.resolveMedia(this.#client, 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(this.#client, p.footer_icon ?? p.icon ?? '', 'image'),
+			is_carousel: posts.length > 1,
+			orientation: p.orientation ?? 'LANDSCAPE',
+			post_type: p.post_type ?? 'VIDEO',
+			__typename: 'GenAIPostPrimitive',
+		}));
+
+		const section = AIRich.newLayout('HScroll', primitives);
+
+		const submessage = this.createAlert('GenAIPostPrimitive');
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addMetadata(text, { id, replace, insertAt } = {}) {
+		if (typeof text !== 'string') {
+			throw new TypeError('Text must be a string');
+		}
+
+		const section = AIRich.newLayout('Single', {
+			text,
+			__typename: 'GenAIMetadataTextPrimitive',
+		});
+
+		const submessage = {
+			messageType: 2,
+			messageText: text,
+		};
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addTip(text, { id, replace, insertAt } = {}) {
+		if (typeof text !== 'string') {
+			throw new TypeError('Text must be a string');
+		}
+
+		const section = AIRich.newLayout('Single', {
+			text: 'ⓘ ' + text,
+			__typename: 'GenAIMetadataTextPrimitive',
+		});
+
+		const submessage = {
+			messageType: 2,
+			messageText: text,
+		};
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addWidget(data, { layout, id, replace, insertAt, ...options } = {}) {
+		if (!((data && typeof data === 'object' && !Array.isArray(data)) || (Array.isArray(data) && data.every((item) => item && typeof item === 'object' && !Array.isArray(item))))) {
+			throw new TypeError('Widget must be an object or an array of objects');
+		}
+
+		const isArray = Array.isArray(data);
+
+		const items = isArray ? data : [data];
+
+		const widgets = items.map((item) => ({
+			__typename: 'GenAI3PExtWidgetPrimitive',
+
+			header: {
+				__typename: 'GenAI3PExtWidgetStandardHeader',
+				title: item.title ?? '',
+				...(item.header ?? {}),
+			},
+
+			body: {
+				__typename: 'GenAI3PExtCalendarEventList',
+				sections: item.sections ?? [],
+
+				ctas: (item.actions ?? []).map((action) => ({
+					__typename: 'GenAI3PExtWidgetCTA',
+					label: action.label ?? '',
+					state: action.state ?? 'PENDING',
+					kind: action.kind ?? 'OTHER',
+					tool_call_id: action.tool_call_id ?? action.id ?? '',
+
+					...(action.toast && {
+						toast: {
+							__typename: 'GenAI3PExtWidgetToast',
+							label: action.toast.label ?? action.label ?? '',
+						},
+					}),
+				})),
+
+				...(item.body ?? {}),
+			},
+		}));
+
+		const section = AIRich.newLayout(layout ?? (isArray ? 'HScroll' : 'Single'), isArray ? widgets : widgets[0], options);
+
+		const submessage = this.createAlert('GenAI3PExtWidgetStandardHeader');
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addFooterAction(data, { layout, id, replace, insertAt, ...options } = {}) {
+		if (!((data && typeof data === 'object' && !Array.isArray(data)) || (Array.isArray(data) && data.every((item) => item && typeof item === 'object' && !Array.isArray(item))))) {
+			throw new TypeError('Footer action must be an object or an array of objects');
+		}
+
+		const isArray = Array.isArray(data);
+
+		const items = isArray ? data : [data];
+
+		const actions = items.map((item) => ({
+			__typename: 'GenAIFooterActionPrimitive',
+
+			cta_text: item.text ?? item.cta_text ?? '',
+
+			cta_type: item.type ?? item.cta_type ?? 'OPEN_URL',
+
+			cta_url: item.url ?? item.cta_url ?? '',
+		}));
+
+		const section = AIRich.newLayout(layout ?? (isArray ? 'HScroll' : 'Single'), isArray ? actions : actions[0], options);
+
+		const submessage = this.createAlert('GenAIFooterActionPrimitive');
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	addSuggest(suggestion, { scroll = true, layout, id, replace, insertAt } = {}) {
+		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');
+
+		const section = AIRich.newLayout(type, type === 'Single' ? suggest[0] : suggest, {
+			__typename: 'GenAIUnifiedResponseSection',
+		});
+
+		const submessage = this.createAlert('GenAIFollowUpSuggestionPillPrimitive');
+
+		return this._addContent(section, submessage, {
+			id,
+			replace,
+			insertAt,
+		});
+	}
+
+	async build(
+		jid,
+		{ bypassDownload = true, forwarded = true, notification = false, includesUnifiedResponse = true, includesSubmessages = true, quoted, quotedParticipant, messageId, ...options } = {}
+	) {
+		const forward = forwarded
+			? {
+					forwardingScore: 1,
+					isForwarded: true,
+					forwardedAiBotMessageInfo: { botJid: '867051314767696@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?.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))];
+
+		if (this._dynamic) {
+			this.refreshResponseId();
+			this.refreshBotResponseId();
+		}
+
+		return generateWAMessageFromContent(
+			jid,
+			{
+				messageContextInfo: {
+					deviceListMetadata: {},
+					deviceListMetadataVersion: 2,
+					botMetadata: {
+						messageDisclaimerText: this._title,
+						...notif,
+						verificationMetadata: AIRich.generateVerificationMetadata(),
+						botResponseId: this._botResponseId,
+					},
+				},
+				...this._extraPayload,
+				botForwardedMessage: {
+					message: {
+						richResponseMessage: {
+							messageType: 1,
+							submessages: includesSubmessages ? await waitAllPromises(this._submessages) : [],
+							unifiedResponse: {
+								data: includesUnifiedResponse ? Buffer.from(Toolkit.stringifyEscaped({ response_id: this._responseId, sections })).toString('base64') : '',
+							},
+							contextInfo: {
+								...forward,
+								...qObj,
+								...this._contextInfo,
+							},
+						},
+					},
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+	}
+
+	async buildEdit(targetJid, targetId, { msg, messageId, ...options } = {}) {
+		if (!msg) {
+			msg = (await this.build(targetJid, options)).message;
+		}
+
+		const editedMessage = msg;
+
+		if (!editedMessage) {
+			throw new Error('buildEdit: msg does not contain botForwardedMessage');
+		}
+
+		return generateWAMessageFromContent(
+			targetJid,
+			{
+				botForwardedMessage: {
+					message: {
+						protocolMessage: {
+							key: {
+								remoteJid: targetJid,
+								fromMe: true,
+								id: targetId,
+							},
+							type: 14,
+							editedMessage,
+						},
+					},
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+	}
+
+	async sendEdit(jid, id, { msg, messageId, additionalNodes = [], ...options } = {}) {
+		jid = jid ?? this._lastMessageKey?.remoteJid;
+		id = id ?? this._lastMessageKey?.id;
+
+		if (!jid) {
+			throw new Error('JID is required');
+		}
+
+		if (!id) {
+			throw new Error('Message id is required');
+		}
+
+		const msgEdit = await this.buildEdit(jid, id, {
+			msg,
+			messageId: messageId || generateMessageIDV2(),
+			...options,
+		});
+
+		await this.#client.relayMessage(jid, msgEdit.message, {
+			messageId: msgEdit.key.id,
+			additionalNodes,
+		});
+
+		return msgEdit;
+	}
+
+	async send(jid, { bypassDownload = true, forwarded = true, notification = false, includesUnifiedResponse = true, includesSubmessages = true, messageId, additionalNodes = [], ...options } = {}) {
+		const msg = await this.build(jid, {
+			forwarded,
+			notification,
+			includesUnifiedResponse,
+			includesSubmessages,
+			messageId,
+			...options,
+		});
+
+		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
+			messageId: msg.key.id,
+			additionalNodes,
+			...options,
+		});
+
+		if (includesUnifiedResponse && bypassDownload) {
+			await this.sendEdit(jid, msg.key.id, {
+				msg: msg.message,
+			});
+		}
+
+		this._lastMessageKey = msg.key;
+
+		return msg;
+	}
+
+	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 generateVerificationMetadata() {
+		const signatureMaterial = Buffer.from(
+			`\u004E\u0049\u0058\u0045\u004C\u002E\u004D\u0065\u0073\u0073\u0061\u0067\u0065\u0042\u0075\u0069\u006C\u0064\u0065\u0072\u0056${VERSION}\u002D\u0056\u0065\u0072\u0069\u0066\u0069\u0063\u0061\u0074\u0069\u006F\u006E\u0053\u0069\u0067\u006E\u0061\u0074\u0075\u0072\u0065\u002E\u004D\u0065\u0074\u0061\u0064\u0061\u0074\u0061`
+		);
+
+		const certificateMaterial = Buffer.from(
+			`\u004E\u0049\u0058\u0045\u004C\u002E\u004D\u0065\u0073\u0073\u0061\u0067\u0065\u0042\u0075\u0069\u006C\u0064\u0065\u0072\u0056${VERSION}\u002D\u0043\u0065\u0072\u0074\u0069\u0066\u0069\u0063\u0061\u0074\u0065\u0043\u0068\u0061\u0069\u006E\u002E\u004D\u0065\u0074\u0061\u0064\u0061\u0074\u0061`
+		);
+
+		const signature = Buffer.concat([signatureMaterial, crypto.randomBytes(64 - signatureMaterial.length)]).toString('base64');
+
+		const certificateChain = [
+			Buffer.concat([certificateMaterial, crypto.randomBytes(684 - certificateMaterial.length)]).toString('base64'),
+
+			Buffer.concat([certificateMaterial, crypto.randomBytes(892 - certificateMaterial.length)]).toString('base64'),
+		];
+
+		return {
+			proofs: [
+				{
+					version: 1,
+					useCase: 1,
+					signature,
+					certificateChain,
+				},
+			],
+		};
+	}
+
+	static newLayout(name, data, extra = {}) {
+		return {
+			...extra,
+			view_model: {
+				[Array.isArray(data) ? 'primitives' : 'primitive']: data,
+				__typename: `GenAI${name}LayoutViewModel`,
+			},
+		};
+	}
+
+	_makeNode(id, section, submessage) {
+		return { id: id ?? null, section: section ?? null, submessage: submessage ?? null };
+	}
+
+	_registerId(node, id) {
+		if (id === undefined || id === null || id === '') return;
+
+		if (typeof id !== 'string') {
+			throw new ContentValidationError('Item id must be a string', { id });
+		}
+
+		if (this._idIndex.has(id)) {
+			throw new DuplicateIdError(id);
+		}
+
+		node.id = id;
+		this._idIndex.set(id, node);
+	}
+
+	_unregisterId(node) {
+		if (node.id && this._idIndex.get(node.id) === node) {
+			this._idIndex.delete(node.id);
+		}
+	}
+
+	hasId(id) {
+		return typeof id === 'string' && this._idIndex.has(id);
+	}
+
+	getIds() {
+		return [...this._idIndex.keys()];
+	}
+
+	peek(id) {
+		const node = this._idIndex.get(id);
+
+		if (!node) return null;
+
+		return {
+			id: node.id,
+			section: node.section,
+			submessage: node.submessage,
+		};
+	}
+
+	assignId(index, id) {
+		if (!Number.isInteger(index) || index < 0 || index >= this._nodes.length) {
+			throw new InvalidTargetError(`Node index ${index} is out of range (0-${this._nodes.length - 1})`, { index });
+		}
+
+		const node = this._nodes[index];
+
+		if (node.id) {
+			throw new AIRichError(`Node at index ${index} already has id "${node.id}"`, 'ALREADY_HAS_ID', { index, id: node.id });
+		}
+
+		this._registerId(node, id);
+
+		return this;
+	}
+
+	_getNode(id) {
+		if (typeof id !== 'string' || !id) {
+			throw new ContentValidationError('Item id must be a non-empty string', { id });
+		}
+
+		const node = this._idIndex.get(id);
+
+		if (!node) {
+			throw new ItemNotFoundError(id, this.getIds());
+		}
+
+		return node;
+	}
+
+	_resolveTarget(target) {
+		if (Array.isArray(target)) {
+			if (target.length < 1 || target.length > 2) {
+				throw new ContentValidationError('Target must be id or [id, offset]', { target });
+			}
+
+			const [id, offset = 0] = target;
+
+			if (typeof id !== 'string' || !id) {
+				throw new ContentValidationError('Target id must be a non-empty string', { target });
+			}
+
+			if (!Number.isInteger(offset)) {
+				throw new ContentValidationError('Offset must be an integer', { target });
+			}
+
+			return { id, offset };
+		}
+
+		if (typeof target !== 'string' || !target) {
+			throw new ContentValidationError('Target must be a non-empty id or [id, offset]', { target });
+		}
+
+		return { id: target, offset: 0 };
+	}
+
+	_resolveNodeIndex(target) {
+		const { id, offset } = this._resolveTarget(target);
+		const node = this._getNode(id);
+		const baseIndex = this._nodes.indexOf(node);
+
+		if (baseIndex === -1) {
+			throw new InvalidTargetError(`Item id "${id}" is registered but not present in the node list (internal desync)`, { id });
+		}
+
+		const index = baseIndex + offset;
+
+		if (index < 0 || index >= this._nodes.length) {
+			throw new InvalidTargetError(`Target "${id}" with offset ${offset} resolves to index ${index}, which is out of range (0-${this._nodes.length - 1})`, { id, offset, index });
+		}
+
+		return { id, offset, baseIndex, index };
+	}
+
+	_validateSections(section) {
+		const items = Array.isArray(section) ? section : [section];
+
+		if (!items.length) {
+			throw new ContentValidationError('At least one section is required');
+		}
+
+		for (const item of items) {
+			if (!item || typeof item !== 'object' || Array.isArray(item)) {
+				throw new ContentValidationError('Sections must be plain objects');
+			}
+		}
+
+		return items;
+	}
+
+	_validateSubmessages(submessage) {
+		if (submessage === undefined || submessage === null) {
+			return [];
+		}
+
+		const items = Array.isArray(submessage) ? submessage : [submessage];
+
+		for (const item of items) {
+			if (!item || typeof item !== 'object' || Array.isArray(item)) {
+				throw new ContentValidationError('Submessages must be plain objects');
+			}
+		}
+
+		return items;
+	}
+
+	_pairSubmessages(sections, submessages) {
+		const n = sections.length;
+		const m = submessages.length;
+
+		if (m === 0) return sections.map(() => null);
+		if (m === 1) return sections.map((_, i) => (i === 0 ? submessages[0] : null));
+		if (m === n) return submessages;
+
+		throw new ContentValidationError(`Cannot pair ${m} submessage(s) with ${n} section(s): expected 0, 1, or ${n}`, { sectionCount: n, submessageCount: m });
+	}
+
+	_addContent(section, submessage, { id, replace, insertAt } = {}) {
+		const hasReplace = replace !== undefined && replace !== null && replace !== '';
+
+		const hasInsertAt = insertAt !== undefined && insertAt !== null && insertAt !== '';
+
+		if (hasReplace && hasInsertAt) {
+			throw new ContentValidationError('replace and insertAt cannot be used together');
+		}
+
+		const sections = this._validateSections(section);
+		const submessages = this._validateSubmessages(submessage);
+
+		if (!sections.length) {
+			throw new ContentValidationError('At least one section is required');
+		}
+
+		if (id !== undefined && id !== null && id !== '' && sections.length !== 1) {
+			throw new ContentValidationError('One id can only be assigned to one node', {
+				id,
+				sectionCount: sections.length,
+			});
+		}
+
+		if (submessages.length && submessages.length !== sections.length && submessages.length !== 1) {
+			throw new ContentValidationError('Section and submessage count must match');
+		}
+
+		const pairedSubmessages = sections.map((_, index) => {
+			if (!submessages.length) return undefined;
+
+			return submessages.length === 1 ? submessages[0] : submessages[index];
+		});
+
+		if (id && this._idIndex.has(id) && !(hasReplace && this._resolveTarget(replace)?.id === id)) {
+			throw new DuplicateIdError(id);
+		}
+
+		const newNodes = sections.map((currentSection, index) => {
+			return this._makeNode(index === 0 ? id : null, currentSection, pairedSubmessages[index]);
+		});
+
+		if (hasReplace) {
+			if (newNodes.length !== 1) {
+				throw new ContentValidationError('replace only supports adding exactly one node');
+			}
+
+			const target = this._resolveNodeIndex(replace);
+
+			if (!target) {
+				throw new ContentValidationError('Target node could not be resolved');
+			}
+
+			const oldNode = this._nodes[target.index];
+			const newNode = newNodes[0];
+
+			if (!newNode.id && oldNode?.id) {
+				newNode.id = oldNode.id;
+			}
+
+			this._unregisterId(oldNode);
+
+			this._nodes.splice(target.index, 1, newNode);
+
+			if (newNode.id) {
+				this._idIndex.set(newNode.id, newNode);
+			}
+
+			return this;
+		}
+
+		if (hasInsertAt) {
+			const target = this._resolveNodeIndex(insertAt);
+
+			if (!target) {
+				throw new ContentValidationError('Target node could not be resolved');
+			}
+
+			const insertIndex = target.offset < 0 ? target.index : target.index + 1;
+
+			this._nodes.splice(insertIndex, 0, ...newNodes);
+
+			for (const node of newNodes) {
+				if (node.id) {
+					this._idIndex.set(node.id, node);
+				}
+			}
+
+			return this;
+		}
+
+		this._nodes.push(...newNodes);
+
+		for (const node of newNodes) {
+			if (node.id) {
+				this._idIndex.set(node.id, node);
+			}
+		}
+
+		return this;
+	}
+
+	addCompact({ title = '', subtitle = '', secondary_subtitle = '', image, entity_id = '', entity_url = '', entity_type = 'WEBSITE', action_type = 'OPEN_URL' } = {}) {
+		const key = `NIXEL_COMPACT_ENTITY_${this._nodes.length + 1}`;
+		const entityName = String(entity_id || title || '').trim();
+		const heading = [title, subtitle, secondary_subtitle]
+			.filter((value) => typeof value === 'string' && value.trim())
+			.join('\n');
+		const text = [heading, entityName ? `{{${key}}}${entityName}{{/${key}}}` : '']
+			.filter(Boolean)
+			.join('\n\n');
+		const section = AIRich.newLayout('VStack', [{
+			text,
+			...(entityName && entity_url ? {
+				inline_entities: [{
+					key,
+					metadata: {
+						entity_id: String(entity_id || entityName),
+						entity_name: entityName,
+						...(image ? { entity_picture_url: image } : {}),
+						entity_url,
+						entity_type,
+						action_type,
+						__typename: 'GenAISocialEntityItem',
+					},
+				}],
+			} : {}),
+			__typename: 'GenAIMarkdownTextUXPrimitive',
+		}]);
+		return this.addSection(section);
+	}
+
+	addSection(section, options = {}) {
+		return this._addContent(section, undefined, options);
+	}
+
+	addSubmessage(submessage, options = {}) {
+		const items = this._validateSubmessages(submessage);
+
+		if (!items.length) {
+			throw new ContentValidationError('At least one submessage is required');
+		}
+
+		return this._addContent(undefined, items, options);
+	}
+
+	delete(target) {
+		const { index } = this._resolveNodeIndex(target);
+		const [oldNode] = this._nodes.splice(index, 1);
+
+		this._unregisterId(oldNode);
+
+		return this;
+	}
+
+	get _sections() {
+		return this._nodes.filter((n) => n.section !== null).map((n) => n.section);
+	}
+
+	get _submessages() {
+		return this._nodes.filter((n) => n.submessage !== null).map((n) => n.submessage);
+	}
+
+	get sections() {
+		return this._sections;
+	}
+
+	get items() {
+		return this._sections.flatMap((section) => {
+			const vm = section?.view_model;
+
+			if (Array.isArray(vm?.primitives)) {
+				return vm.primitives;
+			}
+
+			if (vm?.primitive) {
+				return [vm.primitive];
+			}
+
+			return [];
+		});
+	}
+}
+
+export { VERSION, Button, ButtonV2, Carousel, AIRich, Toolkit };