not_null<Main::Session*> session,

Fn<bool(not_null<DocumentData*>)> allowPremiumEmoji) {

return [=](QStringView mimeTag) {

const auto id = session->userId().bare;

auto all = TextUtilities::SplitTags(mimeTag);

auto premiumSkipped = (DocumentData*)nullptr;

for (auto i = all.begin(); i != all.end();) {

const auto tag = *i;

if (TextUtilities::IsMentionLink(tag)

&& TextUtilities::MentionNameDataToFields(tag).selfId != id) {

i = all.erase(i);

continue;

} else if (Ui::InputField::IsCustomEmojiLink(tag)) {

const auto data = Ui::InputField::CustomEmojiEntityData(tag);

const auto emoji = Data::ParseCustomEmojiData(data);

if (!emoji) {

i = all.erase(i);

continue;

} else if (!session->premium()) {

const auto document = session->data().document(emoji);

if (document->isPremiumEmoji()) {

if (!allowPremiumEmoji

|| premiumSkipped

|| !session->premiumPossible()

|| !allowPremiumEmoji(document)) {

premiumSkipped = document;

i = all.erase(i);

continue;

}

}

}

}

++i;

}

return TextUtilities::JoinTag(all);

};

not_null<Ui::GenericBox*> box,

std::shared_ptr<Main::SessionShow> show,

const TextWithTags &startText,

const QString &startLink,

Fn<void(TextWithTags, QString)> callback,

const style::InputField *fieldStyle,

Fn<QString(QString)> validate,

Fn<void(bool)> interactionActive,

Fn<void()> restoreFocus) {

Expects(callback != nullptr);

if (interactionActive) {

interactionActive(true);

}

box->boxClosing() | rpl::on_next([=] {

if (interactionActive) {

interactionActive(false);

}

if (restoreFocus) {

restoreFocus();

}

}, box->lifetime());

const auto &fieldSt = fieldStyle ? *fieldStyle : st::defaultInputField;

const auto content = box->verticalLayout();

const auto text = content->add(

object_ptr<Ui::InputField>(

content,

fieldSt,

Ui::InputField::Mode::SingleLine,

tr::lng_formatting_link_text(),

startText),

st::markdownLinkFieldPadding);

text->setInstantReplaces(Ui::InstantReplaces::Default());

text->setInstantReplacesEnabled(

Core::App().settings().replaceEmojiValue(),

Core::App().settings().systemTextReplaceValue());

Ui::Emoji::SuggestionsController::Init(

box->getDelegate()->outerContainer(),

text,

&show->session());

InitSpellchecker(show, text, fieldStyle != nullptr);

const auto placeholder = content->add(

object_ptr<Ui::RpWidget>(content),

st::markdownLinkFieldPadding);

placeholder->setAttribute(Qt::WA_TransparentForMouseEvents);

const auto link = [&] {

if (!startLink.trimmed().isEmpty()) {

return startLink.trimmed();

}

const auto clipboard = QGuiApplication::clipboard()->text().trimmed();

const auto starts = [&](const auto &protocol) {

return clipboard.startsWith(protocol);

};

return std::ranges::any_of(kLinkProtocols, starts) ? clipboard : QString();

}();

const auto url = Ui::AttachParentChild(

content,

object_ptr<Ui::InputField>(

content,

fieldSt,

tr::lng_formatting_link_url(),

link));

url->heightValue(

) | rpl::on_next([placeholder](int height) {

placeholder->resize(placeholder->width(), height);

}, placeholder->lifetime());

placeholder->widthValue(

) | rpl::on_next([=](int width) {

url->resize(width, url->height());

}, placeholder->lifetime());

url->move(placeholder->pos());

const auto submit = [=] {

const auto linkText = text->getTextWithTags();

const auto linkUrl = validate(url->getLastText());

if (linkText.text.isEmpty()) {

text->showError();

return;

} else if (linkUrl.isEmpty()) {

url->showError();

return;

}

const auto weak = base::make_weak(box);

callback(linkText, linkUrl);

if (weak) {

box->closeBox();

}

};

text->submits(

) | rpl::on_next([=] {

url->setFocusFast();

}, text->lifetime());

url->submits(

) | rpl::on_next([=] {

if (text->getLastText().isEmpty()) {

text->setFocusFast();

} else {

submit();

}

}, url->lifetime());

box->setTitle(url->getLastText().isEmpty()

? tr::lng_formatting_link_create_title()

: tr::lng_formatting_link_edit_title());

box->addButton(tr::lng_formatting_link_create(), submit);

box->addButton(tr::lng_cancel(), [=] { box->closeBox(); });

content->resizeToWidth(st::boxWidth);

content->moveToLeft(0, 0);

box->setWidth(st::boxWidth);

box->setFocusCallback([=] {

if (startText.text.isEmpty()) {

text->setFocusFast();

} else {

if (!url->empty()) {

url->selectAll();

}

url->setFocusFast();

}

});

const auto clearFullSelection = [=](not_null<Ui::InputField*> input) {

if (input->empty()) {

return;

}

auto cursor = input->rawTextEdit()->textCursor();

const auto hasFull = (!cursor.selectionStart()

&& (cursor.selectionEnd()

== (input->rawTextEdit()->document()->characterCount() - 1)));

if (hasFull) {

cursor.clearSelection();

input->setTextCursor(cursor);

}

};

using TabbedRequest = Ui::InputField::TabbedRequest;

url->tabbed(

) | rpl::on_next([=](not_null<TabbedRequest*> request) {

clearFullSelection(url);

text->setFocus();

request->handled = true;

}, url->lifetime());

text->tabbed(

) | rpl::on_next([=](not_null<TabbedRequest*> request) {

if (!url->empty()) {

url->selectAll();

}

clearFullSelection(text);

url->setFocus();

request->handled = true;

}, text->lifetime());

not_null<Ui::GenericBox*> box,

QString now,

Fn<void(QString)> save) {

Expects(save != nullptr);

box->setTitle(tr::lng_formatting_code_title());

box->addRow(object_ptr<Ui::FlatLabel>(

box,

tr::lng_formatting_code_language(),

st::settingsAddReplyLabel));

const auto field = box->addRow(object_ptr<Ui::InputField>(

box,

st::settingsAddReplyField,

tr::lng_formatting_code_auto(),

now.trimmed()));

box->setFocusCallback([=] {

field->setFocusFast();

});

field->selectAll();

field->setMaxLength(kCodeLanguageLimit);

Ui::AddLengthLimitLabel(field, kCodeLanguageLimit);

const auto callback = [=] {

const auto name = field->getLastText().trimmed();

const auto check = QRegularExpression("^[a-zA-Z0-9\\+\\-]*$");

if (check.match(name).hasMatch()) {

auto weak = base::make_weak(box);

save(name);

if (const auto strong = weak.get()) {

strong->closeBox();

}

} else {

field->showError();

}

};

field->submits(

) | rpl::on_next(callback, field->lifetime());

box->addButton(tr::lng_settings_save(), callback);

box->addButton(tr::lng_cancel(), [=] {

box->closeBox();

});

static const auto expression = QRegularExpression(

u"\\n?#tsf[a-z0-9_-]*[\\s#a-z0-9_-]*$"_q,

QRegularExpression::CaseInsensitiveOption);

const auto match = expression.match(text.text);

if (!match.hasMatch()) {

return text;

}

text.text.chop(match.capturedLength());

const auto length = text.text.size();

if (!length) {

return TextWithEntities();

}

for (auto i = text.entities.begin(); i != text.entities.end();) {

auto &entity = *i;

if (entity.offset() >= length) {

i = text.entities.erase(i);

continue;

} else if (entity.offset() + entity.length() > length) {

entity.shrinkFromRight(length - entity.offset());

}

++i;

}

return text;

return TextUtilities::kMentionTagStart

+ QString::number(user->id.value)

+ '.'

+ QString::number(user->accessHash())

+ ':'

+ QString::number(user->session().userId().bare);

auto original = item->history()->session().supportMode()

? StripSupportHashtag(item->originalText())

: item->originalText();

original = DropDisallowedCustomEmoji(

item->history()->peer,

std::move(original));

return TextWithTags{

original.text,

TextUtilities::ConvertEntitiesToTextTags(original.entities)

};

not_null<HistoryItem*> item,

TextWithTags updated) {

const auto original = PrepareEditText(item);

auto originalWithEntities = TextWithEntities{

std::move(original.text),

TextUtilities::ConvertTextTagsToEntities(original.tags)

};

auto updatedWithEntities = TextWithEntities{

std::move(updated.text),

TextUtilities::ConvertTextTagsToEntities(updated.tags)

};

TextUtilities::PrepareForSending(originalWithEntities, 0);

TextUtilities::PrepareForSending(updatedWithEntities, 0);

// Tags can be different for the same entities, because for

// animated emoji each tag contains a different random number.

// So we compare entities instead of tags.

return originalWithEntities != updatedWithEntities;

std::shared_ptr<Main::SessionShow> show,

not_null<Ui::InputField*> field,

const style::InputField *fieldStyle,

Fn<QString(QString)> linkValidator,

Fn<void(bool)> interactionActive,

Fn<void()> restoreFocus) {

const auto weak = base::make_weak(field);

return [=](

EditLinkSelection selection,

TextWithTags text,

QString link,

EditLinkAction action) {

if (action == EditLinkAction::Check) {

return (Ui::InputField::IsValidMarkdownLink(link)

&& !TextUtilities::IsMentionLink(link))

|| Ui::InputField::IsCustomDateLink(link)

|| (linkValidator && !linkValidator(link).isEmpty());

}

if (Ui::InputField::IsCustomDateLink(link)) {

const auto dateStr = link.mid(

Ui::InputField::kCustomDateTagStart.size());

const auto existingDate = dateStr.toInt();

auto callback = [=](

const TextWithTags &t,

const QString &l) {

if (const auto strong = weak.get()) {

strong->commitMarkdownLinkEdit(selection, t, l);

}

};

const auto savedCallback = std::make_shared<

Fn<void(const TextWithTags &, const QString &)>>(

std::move(callback));

const auto savedText = std::make_shared<TextWithTags>(text);

const auto showDateTimeBox = [=](TimeId time) {

const auto dateBox = std::make_shared<

base::weak_qptr<Ui::GenericBox>>();

*dateBox = show->show(Box(

Ui::ChooseDateTimeBox,

Ui::ChooseDateTimeBoxArgs{

.title = tr::lng_formatting_date_title(),

.submit = tr::lng_settings_save(),

.done = [=](TimeId result) {

const auto dateLink

= Ui::InputField::kCustomDateTagStart

+ QString::number(result);

(*savedCallback)(

*savedText,

dateLink);

if (const auto box = dateBox->get()) {

box->closeBox();

}

},

.min = [] { return TimeId(1); },

.time = time,

.max = [] { return TimeId(2114380800); },

}));

};

if (existingDate > 0) {

showDateTimeBox(existingDate);

} else {

show->show(Box<Ui::CalendarBox>(Ui::CalendarBoxArgs{

.month = QDate::currentDate(),

.highlighted = QDate::currentDate(),

.callback = [=](QDate chosen, Fn<void()> close) {

close();

const auto midday = QDateTime(

chosen,

QTime(12, 0));

showDateTimeBox(

base::unixtime::serialize(midday));

},

.minDate = QDate(1970, 1, 1),

.maxDate = QDate(2036, 12, 31),

}));

}

return true;

}

auto callback = [=](const TextWithTags &text, const QString &link) {

if (const auto strong = weak.get()) {

strong->commitMarkdownLinkEdit(selection, text, link);

}

};

const auto validateLink = linkValidator

? linkValidator

: Fn<QString(QString)>(qthelp::validate_url);

show->showBox(Box(

EditLinkBox,

show,

text,

link,

std::move(callback),

fieldStyle,

validateLink,

interactionActive,

restoreFocus));

return true;

};

std::shared_ptr<Ui::Show> show) {

return [=](QString now, Fn<void(QString)> save) {

show->showBox(Box(EditCodeLanguageBox, now, save));

};

-> std::shared_ptr<Ui::ChatStyle> {

const auto paused = [passed = args.customEmojiPaused] {

return passed && passed();

};

const auto field = args.field;

const auto session = args.session;

field->setTagMimeProcessor(

FieldTagMimeProcessor(session, args.allowPremiumEmoji));

field->setCustomTextContext(Core::TextContext({

.session = session

}), [paused] {

return On(PowerSaving::kEmojiChat) || paused();

}, [paused] {

return On(PowerSaving::kChatSpoiler) || paused();

});

field->setInstantReplaces(Ui::InstantReplaces::Default());

field->setInstantReplacesEnabled(

Core::App().settings().replaceEmojiValue(),

Core::App().settings().systemTextReplaceValue());

field->setMarkdownReplacesEnabled(rpl::single(Ui::MarkdownEnabledState{

Ui::MarkdownEnabled{

std::move(args.allowMarkdownTags),

args.allowTypedMarkdown

}

}));

if (const auto &show = args.show) {

field->setEditLinkCallback(

DefaultEditLinkCallback(

show,

field,

args.fieldStyle,

args.linkValidator));

field->setEditLanguageCallback(DefaultEditLanguageCallback(show));

InitSpellchecker(show, field, args.fieldStyle != nullptr);

}

const auto style = std::make_shared<Ui::ChatStyle>(

session->colorIndicesValue());

field->setPreCache([=] {

return style->messageStyle(false, false).preCache.get();

});

field->setBlockquoteCache([=] {

const auto colorIndex = session->user()->colorIndex();

return style->coloredQuoteCache(false, colorIndex).get();

});

return style;

std::shared_ptr<Main::SessionShow> show,

not_null<Ui::InputField*> field) {

const auto weak = base::make_weak(field);

return [=](

EditLinkSelection selection,

TextWithTags text,

QString link,

EditLinkAction action) {

const auto validate = [=](QString url) {

if (IsGoodFactcheckUrl(url)) {

const auto start = u"https://"_q;

return url.startsWith(start) ? url : (start + url);

}

show->showToast(

tr::lng_factcheck_links(tr::now, tr::rich));

return QString();

};

if (action == EditLinkAction::Check) {

return IsGoodFactcheckUrl(link);

}

auto callback = [=](const TextWithTags &text, const QString &link) {

if (const auto strong = weak.get()) {

strong->commitMarkdownLinkEdit(selection, text, link);

}

};

show->showBox(Box(

EditLinkBox,

show,

text,

link,

std::move(callback),

nullptr,

validate,

nullptr,

nullptr));

return true;

};

std::shared_ptr<Main::SessionShow> show) {

Expects(show != nullptr);

return [=](not_null<Ui::InputField*> field) {

field->setTagMimeProcessor([](QStringView mimeTag) {

using Field = Ui::InputField;

auto all = TextUtilities::SplitTags(mimeTag);

for (auto i = all.begin(); i != all.end();) {

const auto tag = *i;

if (tag != Field::kTagBold

&& tag != Field::kTagItalic

&& (!Field::IsValidMarkdownLink(mimeTag)

|| TextUtilities::IsMentionLink(mimeTag))) {

i = all.erase(i);

continue;

}

++i;

}

return TextUtilities::JoinTag(all);

});

field->setInstantReplaces(Ui::InstantReplaces::Default());

field->setInstantReplacesEnabled(

Core::App().settings().replaceEmojiValue(),

Core::App().settings().systemTextReplaceValue());

field->setMarkdownReplacesEnabled(rpl::single(

Ui::MarkdownEnabledState{

Ui::MarkdownEnabled{

{ Ui::InputField::kTagBold, Ui::InputField::kTagItalic }

}

}

));

field->setEditLinkCallback(FactcheckEditLinkCallback(show, field));

InitSpellchecker(show, field);

};

not_null<Window::SessionController*> controller,

not_null<Ui::InputField*> field,

ChatHelpers::PauseReason pauseReasonLevel,

Fn<bool(not_null<DocumentData*>)> allowPremiumEmoji) {

InitMessageFieldHandlers({

.session = &controller->session(),

.show = controller->uiShow(),

.field = field,

.customEmojiPaused = [=] {

return controller->isGifPausedAtLeastFor(pauseReasonLevel);

},

.allowPremiumEmoji = std::move(allowPremiumEmoji),

});

field->setMinHeight(

st::historySendSize.height() - 2 * st::historySendPadding);

field->setMaxHeight(st::historyComposeFieldMaxHeight);

// st::messageSendingAnimationTextFromOffset.

field->setDocumentMargin(4.);

field->setAdditionalMargin(style::ConvertScale(4) - 4);

std::shared_ptr<ChatHelpers::Show> show,

not_null<Ui::InputField*> field,

Fn<bool(not_null<DocumentData*>)> allowPremiumEmoji) {

const auto style = InitMessageFieldHandlers({

.session = &show->session(),

.show = show,

.field = field,

.customEmojiPaused = [=] {

return show->paused(ChatHelpers::PauseReason::Any);

},

.allowPremiumEmoji = std::move(allowPremiumEmoji),

});

InitMessageFieldGeometry(field);

return style;

not_null<Window::SessionController*> controller,

not_null<Ui::InputField*> field,

Fn<bool(not_null<DocumentData*>)> allowPremiumEmoji) {

return InitMessageField(

controller->uiShow(),

field,

std::move(allowPremiumEmoji));

std::shared_ptr<Main::SessionShow> show,

not_null<Ui::InputField*> field,

bool skipDictionariesManager) {

#ifndef TDESKTOP_DISABLE_SPELLCHECK

using namespace Spellchecker;

const auto session = &show->session();

const auto menuItem = skipDictionariesManager

? std::nullopt

: std::make_optional(SpellingHighlighter::CustomContextMenuItem{

tr::lng_settings_manage_dictionaries(tr::now),

[=] { show->showBox(Box<Ui::ManageDictionariesBox>(session)); }

});

// The highlighter parents itself to the field's document and registers a

// context-menu hook on the field, so it keeps working without holding it.

Ui::CreateChild<SpellingHighlighter>(

field.get(),

Core::App().settings().spellcheckerEnabledValue(),

menuItem);

#endif // TDESKTOP_DISABLE_SPELLCHECK

const auto &text = field->getTextWithTags().text;

for (const auto &ch : text) {

const auto code = ch.unicode();

if (!IsTrimmed(ch) && !IsReplacedBySpace(code)) {

return true;

}

}

return false;

not_null<Ui::InputField*> field,

const style::color &bg) {

class Fade final : public Ui::RpWidget {

public:

using Ui::RpWidget::RpWidget;

void setFade(QPixmap &&fade) {

_fade = std::move(fade);

}

int resizeGetHeight(int newWidth) override {

return st::historyComposeFieldFadeHeight;

}

private:

void paintEvent(QPaintEvent *event) override {

auto p = QPainter(this);

p.drawTiledPixmap(rect(), _fade);

}

QPixmap _fade;

};

const auto topFade = Ui::CreateChild<Fade>(field.get());

const auto bottomFade = Ui::CreateChild<Fade>(field.get());

const auto generateFade = [=] {

const auto size = QSize(1, st::historyComposeFieldFadeHeight);

auto fade = QPixmap(size * style::DevicePixelRatio());

fade.setDevicePixelRatio(style::DevicePixelRatio());

fade.fill(Qt::transparent);

{

auto p = QPainter(&fade);

auto gradient = QLinearGradient(0, 1, 0, size.height());

gradient.setStops({ { 0., bg->c }, { .9, Qt::transparent } });

p.setPen(Qt::NoPen);

p.setBrush(gradient);

p.drawRect(Rect(size));

}

bottomFade->setFade(fade.transformed(QTransform().scale(1, -1)));

topFade->setFade(std::move(fade));

};

generateFade();

style::PaletteChanged(

) | rpl::on_next([=] {

generateFade();

}, topFade->lifetime());

field->sizeValue(

) | rpl::on_next_done([=](const QSize &size) {

topFade->resizeToWidth(size.width());

bottomFade->resizeToWidth(size.width());

bottomFade->move(

0,

size.height() - st::historyComposeFieldFadeHeight);

}, [t = base::make_weak(topFade), b = base::make_weak(bottomFade)] {

Ui::DestroyChild(t.get());

Ui::DestroyChild(b.get());

}, topFade->lifetime());

const auto descent = field->st().style.font->descent;

rpl::merge(

field->changes(),

field->scrollTop().changes() | rpl::to_empty,

field->sizeValue() | rpl::to_empty

) | rpl::on_next([=] {

// InputField::changes fires before the auto-resize is being applied,

// so for the scroll values to be accurate we enqueue the check.

InvokeQueued(field, [=] {

const auto topHidden = !field->scrollTop().current();

if (topFade->isHidden() != topHidden) {

topFade->setVisible(!topHidden);

}

const auto adjusted = field->scrollTop().current() + descent;

const auto bottomHidden = (adjusted >= field->scrollTopMax());

if (bottomFade->isHidden() != bottomHidden) {

bottomFade->setVisible(!bottomHidden);

}

});

}, topFade->lifetime());

not_null<Main::Session*> session,

not_null<const Ui::InputField*> field) {

auto result = InlineBotQuery();

const auto &full = field->getTextWithTags();

const auto &text = full.text;

const auto textLength = text.size();

auto inlineUsernameStart = 1;

auto inlineUsernameLength = 0;

if (textLength > 2 && text[0] == '@' && text[1].isLetter()) {

inlineUsernameLength = 1;

for (auto i = inlineUsernameStart + 1; i != textLength; ++i) {

const auto ch = text[i];

if (ch.isLetterOrNumber() || ch.unicode() == '_') {

++inlineUsernameLength;

continue;

} else if (!ch.isSpace()) {

inlineUsernameLength = 0;

}

break;

}

auto inlineUsernameEnd = inlineUsernameStart + inlineUsernameLength;

auto inlineUsernameEqualsText = (inlineUsernameEnd == textLength);

auto validInlineUsername = false;

if (inlineUsernameEqualsText) {

validInlineUsername = text.endsWith(u"bot"_q);

} else if (inlineUsernameEnd < textLength && inlineUsernameLength) {

validInlineUsername = text[inlineUsernameEnd].isSpace();

}

if (validInlineUsername) {

if (!full.tags.isEmpty()

&& (full.tags.front().offset

< inlineUsernameStart + inlineUsernameLength)) {

return InlineBotQuery();

}

auto username = base::StringViewMid(text, inlineUsernameStart, inlineUsernameLength);

if (username != result.username) {

result.username = username.toString();

if (const auto peer = session->data().peerByUsername(result.username)) {

if (const auto user = peer->asUser()) {

result.bot = user;

} else {

result.bot = nullptr;

}

result.lookingUpBot = false;

} else {

result.bot = nullptr;

result.lookingUpBot = true;

}

}

if (result.bot

&& (!result.bot->isBot()

|| result.bot->botInfo->inlinePlaceholder.isEmpty())) {

result.bot = nullptr;

} else {

result.query = inlineUsernameEqualsText

? QString()

: text.mid(inlineUsernameEnd + 1);

return result;

}

} else {

inlineUsernameLength = 0;

}

}

if (inlineUsernameLength < 3) {

result.bot = nullptr;

result.username = QString();

}

result.query = QString();

return result;

not_null<const Ui::InputField*> field,

ChatHelpers::ComposeFeatures features) {

auto result = AutocompleteQuery();

const auto cursor = field->textCursor();

if (cursor.hasSelection()) {

return result;

}

const auto position = cursor.position();

const auto document = field->document();

const auto block = document->findBlock(position);

for (auto item = block.begin(); !item.atEnd(); ++item) {

const auto fragment = item.fragment();

if (!fragment.isValid()) {

continue;

}

const auto fragmentPosition = fragment.position();

const auto fragmentEnd = fragmentPosition + fragment.length();

if (fragmentPosition >= position || fragmentEnd < position) {

continue;

}

const auto format = fragment.charFormat();

if (format.isImageFormat()) {

continue;

}

bool mentionInCommand = false;

const auto text = fragment.text();

for (auto i = position - fragmentPosition; i != 0; --i) {

if (text[i - 1] == '@') {

if (!features.autocompleteMentions) {

return {};

}

if ((position - fragmentPosition - i < 1 || text[i].isLetterOrNumber()) && (i < 2 || !(text[i - 2].isLetterOrNumber() || text[i - 2] == '_'))) {

result.fromStart = (i == 1) && (fragmentPosition == 0);

result.query = text.mid(i - 1, position - fragmentPosition - i + 1);

} else if ((position - fragmentPosition - i < 1 || text[i].isLetterOrNumber()) && i > 2 && (text[i - 2].isLetterOrNumber() || text[i - 2] == '_') && !mentionInCommand) {

mentionInCommand = true;

--i;

continue;

}

return result;

} else if (text[i - 1] == '#') {

if (!features.autocompleteHashtags) {

return {};

}

if (i < 2 || !(text[i - 2].isLetterOrNumber() || text[i - 2] == '_')) {

result.fromStart = (i == 1) && (fragmentPosition == 0);

result.query = text.mid(i - 1, position - fragmentPosition - i + 1);

}

return result;

} else if (text[i - 1] == '/') {

if (!features.autocompleteCommands) {

return {};

}

if (i < 2 && !fragmentPosition) {

result.fromStart = (i == 1) && (fragmentPosition == 0);

result.query = text.mid(i - 1, position - fragmentPosition - i + 1);

}

return result;

}

if (position - fragmentPosition - i > 127 || (!mentionInCommand && (position - fragmentPosition - i > 63))) {

break;

}

if (!text[i - 1].isLetterOrNumber() && text[i - 1] != '_') {

break;

}

}

break;

}

return result;

: _field(field)

, _timer([=] { parse(); }) {

_lifetime = _field->changes(

) | rpl::on_next([=] {

const auto length = _field->getTextWithTags().text.size();

if (!length) {

_lastLength = 0;

_timer.cancel();

parse();

return;

}

const auto timeout = (std::abs(length - _lastLength) > 2)

? 0

: kParseLinksTimeout;

if (!_timer.isActive() || timeout < _timer.remainingTime()) {

_timer.callOnce(timeout);

}

_lastLength = length;

});