@vanzxy/baileys 1.3.8 → 1.3.9

package/lib/Utils/MessageBuilder.js

@@ -0,0 +1,2297 @@
+/**
+ * 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';
+
+const MESSAGE_BUILDER_VERSION = '4.6';
+
+import { generateWAMessageFromContent, prepareWAMessageMedia } from './messages.js';
+import { botMetadataSignature, botMetadataCertificate } from './rich-message-utils.js';
+import crypto from 'crypto';
+import { PassThrough, Readable } from '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 import('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 import('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 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 ??= 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);
+			}
+		});
+	}
+}
+
+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 = {};
+	}
+
+	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;
+	}
+
+	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, { ...options } = {}) {
+		const message = await this.toCard();
+
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				interactiveMessage: {
+					...message,
+					contextInfo: this._contextInfo,
+				},
+			},
+			{ ...options }
+		);
+	}
+
+	async send(jid, { ...options } = {}) {
+		const msg = await this.build(jid, 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' } }],
+						},
+					],
+				},
+			],
+			...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 = [];
+	}
+
+	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;
+	}
+
+	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 = 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 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' } }],
+						},
+					],
+				},
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+class Carousel extends BaseBuilder {
+	#client;
+
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		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 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 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' } }],
+						},
+					],
+				},
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+class AIRich extends BaseBuilder {
+	#client;
+
+	constructor(client) {
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		super();
+		this.#client = client;
+		this._contextInfo = {};
+		this._submessages = [];
+		this._sections = [];
+		this._richResponseSources = [];
+	}
+
+	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(this.#client, 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(this.#client, item.profileIconUrl ?? item.profile_url ?? item.profile ?? '', 'image'),
+			_thumbnail: Toolkit.resolveMedia(this.#client, 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(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,
+						},
+					];
+				})();
+
+		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@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(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
+							? 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(this.#client, item.image_url ?? item.image, 'image'),
+			},
+			additional_images: [
+				{
+					url: Toolkit.resolveMedia(this.#client, 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(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',
+		}));
+
+		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.randomUUID();
+
+		return {
+			messageContextInfo: {
+				deviceListMetadata: {},
+				deviceListMetadataVersion: 2,
+				botMetadata: {
+					messageDisclaimerText: this._title,
+					richResponseSourcesMetadata: { sources: this._richResponseSources },
+					botResponseId: responseId,
+					verificationMetadata: {
+						proofs: [
+							{
+								certificateChain: [botMetadataCertificate(), botMetadataCertificate(892)],
+								version: 1,
+								useCase: 1,
+								signature: 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,
+						},
+					},
+				},
+			},
+		};
+	}
+
+	async send(jid, { forwarded, notification, includesUnifiedResponse, includesSubmessages, ...options } = {}) {
+		const msg = await this.build({ forwarded, notification, includesUnifiedResponse, includesSubmessages, ...options });
+
+		return await this.#client.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`,
+			},
+		};
+	}
+}
+
+export { MESSAGE_BUILDER_VERSION, Button, ButtonV2, Carousel, AIRich, Toolkit };