aunubaileys 1.0.41 → 1.0.42

package/README.md

@@ -64,6 +64,10 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.42 / Baru di 1.0.42
+
+- 🧑‍💻 **Full rich responses: highlighted code blocks + tables** — completing the simple `aiRich` branch that has existed since the 1.0.2–1.0.4 era. Send `{ code, language }`, `{ table, title }`, `{ links }`, or prebuilt `{ richResponse }` submessages and the message routes to the new rich response builder (`lib/Utils/rich-message-utils.js`, exported: `tokenizeCode`, `prepareRichResponseMessage`, `toUnified`): code is tokenized per language (keyword tables for 12 languages + a lexer) into highlight blocks, tables become header + body rows, and the `unifiedResponse` rendering payload is assembled automatically. Two adaptations from the source (@itsliaaa/baileys), recorded plainly: **(1)** the source's donation-link fallbacks are removed — a link without a `url` is skipped and no third-party label/URL is ever injected; **(2)** the 6.7.24 proto has **no** `botForwardedMessage` field and no `BotMetadata.verificationMetadata`/`botResponseId`, so on this base the rich response is sent as the Message's own `richResponseMessage` field (the same shape as the existing `aiRich` branch) and the v7 bot-proof apparatus is not fabricated; the enums follow this proto's nested layout.
+
 ### 🆕 What's new in 1.0.41 / Baru di 1.0.41
 
 - 🏷️ **The biz binary node machinery, plus the `secureMetaServiceLabel` option** — the 6.7.24 base never had the `biz` companion node that official clients attach to business/interactive message stanzas. This release ports it in full from @itsliaaa/baileys: `getBizBinaryNode()` (`actual_actors`/`host_storage`/`privacy_mode_ts` attributes + a `quality_control` child, with `native_flow` variants for known flow buttons and a `list` variant for list messages) and the `shouldIncludeBizBinaryNode()` decider. `relayMessage` now attaches the node **automatically** for buttons/list/template/native-flow messages, and the content option `secureMetaServiceLabel: true` forces it onto any message (the secure Meta service label). Both functions are exported for consumers who need to inspect or build the node themselves.

package/lib/Defaults/index.d.ts

@@ -1,5 +1,7 @@
 import { proto } from '../../WAProto/index.js';
 import type { MediaType, SocketConfig } from '../Types/index.js';
+export declare const TEXT_ENCODER: TextEncoder;
+export declare const LEXER_REGEX: RegExp;
 export declare const UNAUTHORIZED_CODES: number[];
 export declare const DEFAULT_ORIGIN = "https://web.whatsapp.com";
 export declare const DEF_CALLBACK_PREFIX = "CB:";

package/lib/Defaults/index.js

@@ -4,6 +4,9 @@ import { Browsers } from '../Utils/index.js';
 import logger from '../Utils/logger.js';
 import defaultVersion from './baileys-version.json' with { type: 'json' };
 const { version } = defaultVersion;
+export const TEXT_ENCODER = new TextEncoder();
+// AunuBaileys: lexer untuk tokenisasi kode rich response (dari @itsliaaa/baileys)
+export const LEXER_REGEX = /(\/\/.*|\/\*[\s\S]*?\*\/|#.*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[\s\S]*?`)|(\b[a-zA-Z_]\w*\b)(?=\s*\()|(\b[a-zA-Z_]\w*\b)|(\b\d+(?:\.\d+)?\b)|(\s+|[^\w\s]+)/g;
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const DEF_CALLBACK_PREFIX = 'CB:';

package/lib/Types/Message.d.ts

@@ -242,6 +242,33 @@ export type AnyMessageContent = (AnyRegularMessageContent | {
     ai?: boolean;
     /** AunuBaileys: force the biz binary node (secure Meta service label) onto this message's stanza */
     secureMetaServiceLabel?: boolean;
+    /** AunuBaileys: rich response — a highlighted code block (routes the whole message to the rich response builder) */
+    code?: string;
+    /** language for the rich response code block (default javascript) */
+    language?: string;
+    /** AunuBaileys: rich response — a table; first row is the heading unless noHeading is set */
+    table?: string[][];
+    /** title for the rich response table */
+    title?: string;
+    /** AunuBaileys: rich response — citation links (a link without url is skipped; no fallback is injected) */
+    links?: {
+        text: string;
+        url?: string;
+        title?: string;
+        displayName?: string;
+        sources?: {
+            displayName?: string;
+            subtitle?: string;
+            url?: string;
+        }[];
+    }[];
+    /** AunuBaileys: rich response — prebuilt submessages */
+    richResponse?: any[];
+    headerText?: string;
+    contentText?: string;
+    footerText?: string;
+    disclaimerText?: string;
+    noHeading?: boolean;
 };
 export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
 type MinimalRelayOptions = {

package/lib/Types/RichType.d.ts

@@ -0,0 +1,2 @@
+export const CodeHighlightType: any;
+export const RichSubMessageType: any;

package/lib/Types/RichType.js

@@ -0,0 +1,22 @@
+export var CodeHighlightType;
+(function (CodeHighlightType) {
+    CodeHighlightType[CodeHighlightType["DEFAULT"] = 0] = "DEFAULT";
+    CodeHighlightType[CodeHighlightType["KEYWORD"] = 1] = "KEYWORD";
+    CodeHighlightType[CodeHighlightType["METHOD"] = 2] = "METHOD";
+    CodeHighlightType[CodeHighlightType["STRING"] = 3] = "STRING";
+    CodeHighlightType[CodeHighlightType["NUMBER"] = 4] = "NUMBER";
+    CodeHighlightType[CodeHighlightType["COMMENT"] = 5] = "COMMENT";
+})(CodeHighlightType || (CodeHighlightType = {}));
+export var RichSubMessageType;
+(function (RichSubMessageType) {
+    RichSubMessageType[RichSubMessageType["UNKNOWN"] = 0] = "UNKNOWN";
+    RichSubMessageType[RichSubMessageType["GRID_IMAGE"] = 1] = "GRID_IMAGE";
+    RichSubMessageType[RichSubMessageType["TEXT"] = 2] = "TEXT";
+    RichSubMessageType[RichSubMessageType["INLINE_IMAGE"] = 3] = "INLINE_IMAGE";
+    RichSubMessageType[RichSubMessageType["TABLE"] = 4] = "TABLE";
+    RichSubMessageType[RichSubMessageType["CODE"] = 5] = "CODE";
+    RichSubMessageType[RichSubMessageType["DYNAMIC"] = 6] = "DYNAMIC";
+    RichSubMessageType[RichSubMessageType["MAP"] = 7] = "MAP";
+    RichSubMessageType[RichSubMessageType["LATEX"] = 8] = "LATEX";
+    RichSubMessageType[RichSubMessageType["CONTENT_ITEMS"] = 9] = "CONTENT_ITEMS";
+})(RichSubMessageType || (RichSubMessageType = {}));

package/lib/Utils/index.js

@@ -2,6 +2,7 @@ export * from './generics.js';
 export * from './decode-wa-message.js';
 export * from './messages.js';
 export * from './messages-media.js';
+export * from './rich-message-utils.js';
 export * from './validate-connection.js';
 export * from './crypto.js';
 export * from './signal.js';

package/lib/Utils/messages.js

@@ -10,6 +10,7 @@ import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
+import { prepareRichResponseMessage } from './rich-message-utils.js';
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getImageProcessingLibrary, getStream, toBuffer } from './messages-media.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -460,7 +461,11 @@ async function prepareStickerPackMessage(stickerPack, options) {
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
-    if ('text' in message) {
+    // AunuBaileys: rich response — blok kode / tabel / tautan (dari @itsliaaa/baileys)
+    if ('code' in message || 'links' in message || 'table' in message || 'richResponse' in message) {
+        m = prepareRichResponseMessage(message);
+    }
+    else if ('text' in message) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
         if (typeof urlInfo === 'undefined') {

package/lib/Utils/rich-message-utils.d.ts

@@ -0,0 +1,8 @@
+import type { proto } from '../../WAProto/index.js';
+export declare const tokenizeCode: (code: string, language?: string) => {
+    highlightType: number;
+    codeContent: string;
+}[];
+export declare const toUnified: (submessages: any[], uuid?: string) => any;
+export declare const prepareRichResponseMessage: (content: any) => any;
+export declare const wrapToBotForwardedMessage: (richResponseMessage: proto.AIRichResponseMessage) => any;

package/lib/Utils/rich-message-utils.js

@@ -0,0 +1,339 @@
+/**
+ * AunuBaileys: dukungan tabel & blok kode lewat richResponseMessage
+ * (dibungkus botForwardedMessage). Diadaptasi dari @itsliaaa/baileys —
+ * kredit untuk pembuat asli dipertahankan sesuai catatan mereka.
+ * Deviasi AunuBaileys: fallback link donasi sumber TIDAK ikut dibawa;
+ * tautan tanpa url dilewati, label kosong tetap kosong.
+ */
+import { randomUUID } from 'node:crypto';
+import { LEXER_REGEX, TEXT_ENCODER } from '../Defaults/index.js';
+import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
+import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
+import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from './generics.js';
+const NOOP = new Set([]);
+export const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        }
+        else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        }
+        else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3],
+            });
+        }
+        else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4],
+            });
+        }
+        else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        }
+        else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+// Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
+export const toUnified = (submessages, uuid) => ({
+    response_id: uuid || randomUUID(),
+    sections: submessages.map((submessage, index) => {
+        switch (submessage.messageType) {
+            case RichSubMessageType.CODE:
+                const codeMetadata = submessage.codeMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            language: codeMetadata.codeLanguage,
+                            code_blocks: codeMetadata.codeBlocks.map((block) => ({ content: block.codeContent, type: CodeHighlightType[block.highlightType] })),
+                            __typename: 'GenAICodeUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.CONTENT_ITEMS:
+                return {};
+            case RichSubMessageType.INLINE_IMAGE:
+                return {};
+            case RichSubMessageType.LATEX:
+                return {};
+            case RichSubMessageType.TABLE:
+                const tableMetadata = submessage.tableMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            title: tableMetadata.title,
+                            rows: tableMetadata.rows.map((row) => ({
+                                is_header: row.isHeading,
+                                cells: row.items,
+                                markdown_cells: row.items.map((item) => ({ text: item }))
+                            })),
+                            __typename: 'GenATableUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.TEXT:
+                return {
+                    view_model: {
+                        primitive: {
+                            text: submessage.messageText,
+                            inline_entities: submessage.inlineEntities || [],
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+        }
+        return submessage;
+    })
+});
+export const prepareRichResponseMessage = (content) => {
+    let { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
+    let submessages = [];
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
+                };
+            }
+            else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                };
+            }
+            else if (submessage.items) {
+                return {
+                    messageType: RichSubMessageType.CONTENT_ITEMS,
+                    contentItemsMetadata: {
+                        itemsMetadata: submessage.items,
+                        contentType: proto.AIRichResponseMessage.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                    }
+                };
+            }
+            else if (submessage.inlineImage) {
+                return {
+                    messageType: RichSubMessageType.INLINE_IMAGE,
+                    imageMetadata: {
+                        imageUrl: submessage.inlineImage,
+                        imageText: submessage.imageText,
+                        alignment: submessage.alignment,
+                        tapLinkUrl: submessage.tapLinkUrl
+                    }
+                };
+            }
+            else if (submessage.inlineVideo) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'INLINE_VIDEO'
+                };
+            }
+            else if (submessage.latex) {
+                return {
+                    messageType: RichSubMessageType.LATEX,
+                    latexMetadata: {
+                        text: submessage.text,
+                        expressions: submessage.latex
+                    }
+                };
+            }
+            else if (submessage.posts) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'POSTS'
+                };
+            }
+            else if (submessage.products) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'PRODUCTS'
+                };
+            }
+            else if (submessage.suggested) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'SUGGESTED_PROMPT'
+                };
+            }
+            else if (submessage.table) {
+                return {
+                    messageType: RichSubMessageType.TABLE,
+                    tableMetadata: {
+                        title: submessage.title,
+                        rows: submessage.table
+                    }
+                };
+            }
+            return submessage;
+        });
+    }
+    else {
+        if (headerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: headerText
+            });
+        }
+        if (contentText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: contentText
+            });
+        }
+        if (code) {
+            language || (language = 'javascript');
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: tokenizeCode(code, language)
+                }
+            });
+        }
+        if (items) {
+            submessages.push({
+                messageType: RichSubMessageType.CONTENT_ITEMS,
+                contentItemsMetadata: {
+                    itemsMetadata: items,
+                    contentType: proto.AIRichResponseMessage.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                }
+            });
+        }
+        if (inlineImage) {
+            submessages.push({
+                messageType: RichSubMessageType.INLINE_IMAGE,
+                imageMetadata: {
+                    imageUrl: inlineImage,
+                    imageText,
+                    alignment,
+                    tapLinkUrl
+                }
+            });
+        }
+        if (inlineVideo) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'INLINE_VIDEO'
+            });
+        }
+        if (latex) {
+            submessages.push({
+                messageType: RichSubMessageType.LATEX,
+                latexMetadata: {
+                    text,
+                    expressions: latex
+                }
+            });
+        }
+        if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                if (!linkField.url) {
+                    return;
+                }
+                const url = linkField.url;
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || '',
+                    source_subtitle: sourceField.subtitle || '',
+                    source_url: sourceField.url || url
+                }));
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [{
+                            key: prefix,
+                            metadata: {
+                                reference_id: index + 1,
+                                reference_url: url,
+                                reference_title: linkField.title || '',
+                                reference_display_name: linkField.displayName || '',
+                                sources: sources || [],
+                                __typename: 'GenAISearchCitationItem'
+                            }
+                        }]
+                });
+            });
+        }
+        if (posts) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'POSTS'
+            });
+        }
+        if (products) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'PRODUCTS'
+            });
+        }
+        if (suggested) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'SUGGESTED_PROMPT'
+            });
+        }
+        if (table) {
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((items, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items
+                    }))
+                }
+            });
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: footerText
+            });
+        }
+    }
+    const uuid = randomUUID();
+    const unified = toUnified(submessages, uuid);
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: proto.AIRichResponseMessage.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: TEXT_ENCODER.encode(JSON.stringify(unified)) // Lia@Note 25-04-26 --- Expects "ArrayBufferLike"
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    // AunuBaileys: disclaimerText/botResponseId sumber menempel di botMetadata,
+    // yang tidak terwakili di proto 6.7.24 — keduanya tidak dibuat di sini.
+    void disclaimerText;
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+// AunuBaileys: proto 6.7.24 TIDAK punya field botForwardedMessage maupun
+// BotMetadata.verificationMetadata/botResponseId — rich response di basis ini
+// dikirim sebagai field richResponseMessage langsung pada Message (bentuk yang
+// sama dengan cabang aiRich yang sudah ada), jadi pembungkusnya menyesuaikan.
+export const wrapToBotForwardedMessage = (richResponseMessage) => ({
+    richResponseMessage
+});

package/lib/WABinary/constants.d.ts

@@ -25,4 +25,43 @@ export declare const TOKEN_MAP: {
         index: number;
     };
 };
+export const CPP_KEYWORDS: Set<string>;
+export const CSS_KEYWORDS: Set<string>;
+export const GO_KEYWORDS: Set<string>;
+export const HTML_KEYWORDS: Set<string>;
+export const JS_KEYWORDS: Set<string>;
+export const PYTHON_KEYWORDS: Set<string>;
+export const RUST_KEYWORDS: Set<string>;
+export const C_KEYWORDS: Set<string>;
+export const CSHARP_KEYWORDS: Set<string>;
+export const BASH_KEYWORDS: Set<string>;
+export const CMD_KEYWORDS: Set<string>;
+export const POWERSHELL_KEYWORDS: Set<string>;
+export const LANGUAGE_KEYWORDS: {
+    css: Set<string>;
+    html: Set<string>;
+    javascript: Set<string>;
+    typescript: Set<string>;
+    js: Set<string>;
+    ts: Set<string>;
+    python: Set<string>;
+    py: Set<string>;
+    go: Set<string>;
+    golang: Set<string>;
+    cpp: Set<string>;
+    'c++': Set<string>;
+    rust: Set<string>;
+    rs: Set<string>;
+    c: Set<string>;
+    h: Set<string>;
+    csharp: Set<string>;
+    cs: Set<string>;
+    bash: Set<string>;
+    sh: Set<string>;
+    zsh: Set<string>;
+    cmd: Set<string>;
+    bat: Set<string>;
+    powershell: Set<string>;
+    ps1: Set<string>;
+};
 //# sourceMappingURL=constants.d.ts.map

package/lib/WABinary/constants.js

@@ -1298,4 +1298,172 @@ for (const [i, DOUBLE_BYTE_TOKEN] of DOUBLE_BYTE_TOKENS.entries()) {
         TOKEN_MAP[element] = { dict: i, index: j };
     }
 }
+// AunuBaileys: tabel kata kunci untuk pewarnaan kode rich response (dari @itsliaaa/baileys)
+export const CPP_KEYWORDS = new Set([
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break', 'case',
+    'catch', 'char', 'class', 'compl', 'concept', 'const', 'consteval', 'constexpr', 'constinit',
+    'const_cast', 'continue', 'co_await', 'co_return', 'co_yield', 'decltype', 'default', 'delete',
+    'do', 'double', 'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'float',
+    'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new', 'noexcept',
+    'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private', 'protected', 'public', 'register',
+    'reinterpret_cast', 'requires', 'return', 'short', 'signed', 'sizeof', 'static', 'static_assert',
+    'static_cast', 'struct', 'switch', 'template', 'this', 'thread_local', 'throw', 'true', 'try',
+    'typedef', 'typeid', 'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile',
+    'wchar_t', 'while', 'xor', 'xor_eq'
+]);
+export const CSS_KEYWORDS = new Set([
+    'import', 'media', 'font-face', 'keyframes', 'supports', 'charset',
+    'important', 'root', 'hover', 'active', 'focus', 'visited', 'before', 'after',
+    'not', 'nth-child', 'first-child', 'last-child', 'only-child',
+    'none', 'inherit', 'initial', 'unset', 'auto', 'transparent', 'currentcolor'
+]);
+export const GO_KEYWORDS = new Set([
+    'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct',
+    'chan', 'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type',
+    'continue', 'for', 'import', 'return', 'var', 'true', 'false', 'nil'
+]);
+export const HTML_KEYWORDS = new Set([
+    'html', 'head', 'body', 'title', 'meta', 'link', 'script', 'style',
+    'header', 'footer', 'main', 'section', 'article', 'aside', 'nav',
+    'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'img',
+    'ul', 'ol', 'li', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+    'form', 'input', 'button', 'select', 'textarea', 'label', 'option',
+    'canvas', 'svg', 'iframe', 'video', 'audio', 'source'
+]);
+export const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as',
+    'const', 'let', 'var', 'function', 'class', 'extends', 'new',
+    'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'try', 'catch', 'finally', 'throw',
+    'async', 'await', 'yield',
+    'typeof', 'instanceof', 'in', 'of', 'delete', 'void',
+    'true', 'false', 'null', 'undefined', 'NaN', 'Infinity',
+    'this', 'super', 'static', 'get', 'set',
+    'debugger', 'with'
+]);
+export const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+]);
+export const RUST_KEYWORDS = 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', 'async', 'await', 'dyn',
+    'abstract', 'become', 'box', 'do', 'final', 'macro',
+    'override', 'priv', 'typeof', 'unsized', 'virtual', 'yield',
+    'try'
+]);
+export const C_KEYWORDS = new Set([
+    'auto', 'break', 'case', 'char', 'const', 'continue',
+    'default', 'do', 'double', 'else', 'enum', 'extern',
+    'float', 'for', 'goto', 'if', 'inline', 'int',
+    'long', 'register', 'restrict', 'return', 'short',
+    'signed', 'sizeof', 'static', 'struct', 'switch',
+    'typedef', 'union', 'unsigned', 'void', 'volatile',
+    'while',
+    '_Alignas', '_Alignof', '_Atomic', '_Bool',
+    '_Complex', '_Generic', '_Imaginary',
+    '_Noreturn', '_Static_assert', '_Thread_local'
+]);
+export const CSHARP_KEYWORDS = new Set([
+    'abstract', 'as', 'base', 'bool', 'break', 'byte',
+    'case', 'catch', 'char', 'checked', 'class',
+    'const', 'continue', 'decimal', 'default',
+    'delegate', 'do', 'double', 'else', 'enum',
+    'event', 'explicit', 'extern', 'false', 'finally',
+    'fixed', 'float', 'for', 'foreach', 'goto',
+    'if', 'implicit', 'in', 'int', 'interface',
+    'internal', 'is', 'lock', 'long', 'namespace',
+    'new', 'null', 'object', 'operator', 'out',
+    'override', 'params', 'private', 'protected',
+    'public', 'readonly', 'ref', 'return', 'sbyte',
+    'sealed', 'short', 'sizeof', 'stackalloc',
+    'static', 'string', 'struct', 'switch',
+    'this', 'throw', 'true', 'try', 'typeof',
+    'uint', 'ulong', 'unchecked', 'unsafe',
+    'ushort', 'using', 'virtual', 'void',
+    'volatile', 'while',
+    'async', 'await', 'record', 'init',
+    'required', 'file', 'global', 'nameof',
+    'var', 'dynamic', 'partial', 'yield',
+    'from', 'where', 'select', 'group',
+    'orderby', 'join', 'let', 'into',
+    'equals', 'by', 'ascending', 'descending'
+]);
+export const BASH_KEYWORDS = new Set([
+    'if', 'then', 'else', 'elif', 'fi',
+    'case', 'esac', 'for', 'while',
+    'until', 'do', 'done', 'in',
+    'function', 'select', 'time',
+    'coproc',
+    'echo', 'printf', 'read', 'cd',
+    'pwd', 'exit', 'export', 'unset',
+    'alias', 'unalias', 'source',
+    'exec', 'eval', 'test', 'shift',
+    'trap', 'wait', 'jobs', 'kill',
+    'bg', 'fg', 'history', 'type',
+    'ulimit', 'umask', 'set',
+    'true', 'false'
+]);
+export const CMD_KEYWORDS = new Set([
+    'echo', 'set', 'if', 'else',
+    'for', 'in', 'do', 'goto',
+    'call', 'exit', 'shift',
+    'pause', 'start', 'title',
+    'cls', 'rem',
+    'dir', 'copy', 'move', 'del',
+    'mkdir', 'rmdir', 'type',
+    'ren', 'tasklist', 'taskkill',
+    'ping', 'ipconfig', 'netstat',
+    'shutdown'
+]);
+export const POWERSHELL_KEYWORDS = new Set([
+    'function', 'filter', 'param',
+    'begin', 'process', 'end',
+    'if', 'else', 'elseif',
+    'switch', 'foreach', 'for',
+    'while', 'do', 'until',
+    'break', 'continue', 'return',
+    'throw', 'trap', 'try',
+    'catch', 'finally',
+    '$true', '$false', '$null',
+    'Write-Host', 'Write-Output',
+    'Get-Item', 'Set-Item',
+    'Get-ChildItem', 'Remove-Item',
+    'Copy-Item', 'Move-Item',
+    'Test-Path', 'Invoke-Command'
+]);
+export const LANGUAGE_KEYWORDS = {
+    css: CSS_KEYWORDS,
+    html: HTML_KEYWORDS,
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS,
+    go: GO_KEYWORDS,
+    golang: GO_KEYWORDS,
+    cpp: CPP_KEYWORDS,
+    'c++': CPP_KEYWORDS,
+    rust: RUST_KEYWORDS,
+    rs: RUST_KEYWORDS,
+    c: C_KEYWORDS,
+    h: C_KEYWORDS,
+    csharp: CSHARP_KEYWORDS,
+    cs: CSHARP_KEYWORDS,
+    bash: BASH_KEYWORDS,
+    sh: BASH_KEYWORDS,
+    zsh: BASH_KEYWORDS,
+    cmd: CMD_KEYWORDS,
+    bat: CMD_KEYWORDS,
+    powershell: POWERSHELL_KEYWORDS,
+    ps1: POWERSHELL_KEYWORDS
+};
+
 //# sourceMappingURL=constants.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.41",
+  "version": "1.0.42",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",