return CAPTION_TOO_LONG_RE.test(formatErrorMessage(err));

}

function resolveVoiceFallbackText(reply: ReplyPayload): string | undefined {

if (reply.text?.trim()) {

return reply.text;

}

if (reply.spokenText?.trim()) {

return reply.spokenText;

}

return undefined;

}

async function sendTelegramVoiceFallbackText(opts: {

bot: Bot;

chatId: string;

replyToId?: number;

replyToMode: ReplyToMode;

progress: DeliveryProgress;

}): Promise<number | undefined> {

}): Promise<{ firstDeliveredMessageId?: number; visibleFallbackText?: string }> {

let firstDeliveredMessageId: number | undefined;

let visibleFallbackText: string | undefined;

let first = true;

let pendingFollowUpText: string | undefined;

for (const mediaUrl of params.mediaList) {

await sendVoiceMedia(mediaParams, (err) => !isVoiceMessagesForbidden(err));

} catch (voiceErr) {

if (isVoiceMessagesForbidden(voiceErr)) {

const fallbackText = params.reply.text;

const fallbackText = resolveVoiceFallbackText(params.reply);

if (!fallbackText || !fallbackText.trim()) {

throw voiceErr;

}

if (firstDeliveredMessageId == null) {

firstDeliveredMessageId = fallbackMessageId;

}

visibleFallbackText = fallbackText;

markReplyApplied(params.progress, voiceFallbackReplyTo);

markDelivered(params.progress);

continue;

delete noCaptionParams.caption;

delete noCaptionParams.parse_mode;

await sendVoiceMedia(noCaptionParams);

const fallbackText = params.reply.text;

const fallbackText = resolveVoiceFallbackText(params.reply);

if (fallbackText?.trim()) {

await sendTelegramVoiceFallbackText({

bot: params.bot,

silent: params.silent,

replyMarkup: params.replyMarkup,

});

visibleFallbackText = fallbackText;

}

markReplyApplied(params.progress, replyToMessageId);

continue;

pendingFollowUpText = undefined;

}

}

return firstDeliveredMessageId;

return { firstDeliveredMessageId, visibleFallbackText };

}

async function maybePinFirstDeliveredMessage(params: {

}

const rawContent = resolvedReplyText;

const spokenHookContent =

!rawContent && reply.audioAsVoice === true && reply.spokenText?.trim()

? reply.spokenText

: undefined;

const hookContent = spokenHookContent ?? rawContent;

const replyToId =

params.replyToMode === "off" ? undefined : resolveTelegramReplyId(reply.replyToId);

const replyQuote = resolveReplyQuoteForSend({

const hookResult = await hookRunner?.runMessageSending(

{

to: params.chatId,

content: rawContent,

content: hookContent,

replyToId,

threadId: params.thread?.id,

metadata: {

if (hookResult?.cancel) {

continue;

}

if (typeof hookResult?.content === "string" && hookResult.content !== rawContent) {

reply = { ...reply, text: hookResult.content };

if (typeof hookResult?.content === "string" && hookResult.content !== hookContent) {

reply = spokenHookContent

? { ...reply, spokenText: hookResult.content }

: { ...reply, text: hookResult.content };

}

}

const contentForSentHook = reply.text || "";

let contentForSentHook =

reply.text || (reply.audioAsVoice === true ? resolveVoiceFallbackText(reply) : "") || "";

try {

const deliveredCountBeforeReply = progress.deliveredCount;

progress,

});

} else {

firstDeliveredMessageId = await deliverMediaReply({

const mediaDelivery = await deliverMediaReply({

reply,

mediaList,

bot: params.bot,

replyToMode: params.replyToMode,

progress,

});

firstDeliveredMessageId = mediaDelivery.firstDeliveredMessageId;

if (mediaDelivery.visibleFallbackText) {

contentForSentHook = mediaDelivery.visibleFallbackText;

}

}

await maybePinFirstDeliveredMessage({

pin: reply.delivery?.pin,