// Module ID: 5970
// Function ID: 5971
// Name: AutocompleteUtils
// Dependencies: [32, 5971, 5987, 5428, 6029, 6030, 6034, 4752, 2069, 2120, 1404, 2065, 6087, 4748, 2125, 2119, 2087, 5432, 4750, 5108, 4760, 2116, 4939, 1390, 6088, 1085, 6093, 2072, 3, 6094, 2079, 5076, 6095, 2031, 4962, 6096, 5750, 12, 2039, 1388, 6097, 4755, 5421, 1126, 11, 7041, 2041, 7044, 6925, 7045, 7046, 2046, 7047, 7048, 7054, 7055, 2]
// Exports: getBoosterMap, getGameProfileMatchTier

// Module 5970 (AutocompleteUtils)
import LoggerDefault from "Logger" /* 3 */;
import SnowflakeUtilsDefault from "SnowflakeUtils" /* 11 */;
import _modDef12 from "module_12" /* 12 */;
import intl13 from "intl" /* 1126 */;
import GlobalUtils from "GlobalUtils" /* 1388 */;
import StringUtils from "StringUtils" /* 2031 */;
import UserSettingsProtoActionCreators from "UserSettingsProtoActionCreators" /* 2046 */;
import ChannelConstants from "ChannelConstants" /* 2072 */;
import GuildRoleRecord from "GuildRoleRecord" /* 2120 */;
import PermissionUtilsAll from "PermissionUtils" /* 4755 */;
import UserUtilsDefault from "UserUtils" /* 4962 */;
import RegexUtilsDefault from "RegexUtils" /* 5076 */;
import useChannelName from "useChannelName" /* 5421 */;
import StickersTypes from "StickersTypes" /* 5750 */;
import autocompleter_AutocompleterConstants from "autocompleter/AutocompleterConstants" /* 6093 */;
import utils_AutocompleteUtils from "utils/AutocompleteUtils" /* 6094 */;
import fuzzysearchDefault from "fuzzysearch" /* 6095 */;
import sortByMatchScoreDefault from "sortByMatchScore" /* 6096 */;
import GuildUtilsDefault from "GuildUtils" /* 6097 */;
import OnboardingHomeUtils from "OnboardingHomeUtils" /* 6925 */;
import useGuildOnboardingAvailable from "useGuildOnboardingAvailable" /* 7045 */;
import compareChannelsByScoreAndPositionDefault from "compareChannelsByScoreAndPosition" /* 7046 */;
import isSoundValidDefault from "isSoundValid" /* 7054 */;
import _slicedToArray from "_slicedToArray" /* 32 */;
import InAppNavigationRecord from "InAppNavigationRecord" /* 5971 */;
import EmojiStore from "EmojiStore" /* 5987 */;
import SoundboardStore from "SoundboardStore" /* 5428 */;
import StickersPersistedStore from "StickersPersistedStore" /* 6029 */;
import StickersStore from "StickersStore" /* 6030 */;
import ActiveJoinedThreadsStore from "ActiveJoinedThreadsStore" /* 6034 */;
import JoinedThreadsStore from "JoinedThreadsStore" /* 4752 */;
import ChannelRecord from "ChannelRecord" /* 2069 */;
import UserRecord from "UserRecord" /* 1404 */;
import ChannelStore from "ChannelStore" /* 2065 */;
import FrecencyStore from "FrecencyStore" /* 6087 */;
import GuildChannelStore_mod from "GuildChannelStore" /* 4748 */;
import GuildMemberStore from "GuildMemberStore" /* 2125 */;
import GuildRoleStore from "GuildRoleStore" /* 2119 */;
import GuildStore from "GuildStore" /* 2087 */;
import MessageStore from "MessageStore" /* 5432 */;
import PermissionStore from "PermissionStore" /* 4750 */;
import PresenceStore from "PresenceStore" /* 5108 */;
import RelationshipStore from "RelationshipStore" /* 4760 */;
import SelectedChannelStore from "SelectedChannelStore" /* 2116 */;
import SelectedGuildStore from "SelectedGuildStore" /* 4939 */;
import UserStore from "UserStore" /* 1390 */;
import SKUStore from "SKUStore" /* 6088 */;
import Constants from "Constants" /* 1085 */;
import FunctionUtils from "FunctionUtils" /* 2039 */;
import size from "module_2" /* 2 */;

const require = globalThis.__r;
let _require, dependencyMap, displayName, importDefault, record, set;

let ChannelTypes;
let closure_14;
let closure_15;
let closure_16;
let closure_17;
let closure_18;
let closure_19;
let closure_38;
let closure_39;
let closure_41;
let closure_42;
let hasOwnProperty;
let map1;
let metroRequire;
const f92687 = (author) => author.author.id;
const f92688 = (author) => user.getUser(author.author.id);
function NOOP() {
  return true;
}
function calculateScore() {
  let num = arg0;
  if (arg0 === undefined) {
    num = 0;
  }
  let num2 = arg1;
  const result = 1000 * num;
  if (arg1 == null) {
    num2 = 1;
  }
  return result * num2;
}
function getMatchValue(toLocaleLowerCaseResult1, nextResult, flag) {
  let containQuery;
  let exactQuery;
  let queryLower;
  function multiTokenMatch(queryLower, toLocaleLowerCaseResult1) {
    let closure_0 = toLocaleLowerCaseResult1;
    const parts = queryLower.split(/(?:,| )+/);
    return parts.every((item) => {
      const obj = RegexUtilsDefault;
      const regExp = new RegExp(obj.escape(item), "i");
      return regExp.test(toLocaleLowerCaseResult1);
    });
  }
  ({ exactQuery, containQuery, queryLower } = nextResult);
  if (flag === undefined) {
    flag = true;
  }
  try {
    if (exactQuery.test(toLocaleLowerCaseResult1)) {
      let num5 = 7;
      if (toLocaleLowerCaseResult1.toLocaleLowerCase() === queryLower) {
        num5 = c46;
      }
      return num5;
    } else if (containQuery.test(toLocaleLowerCaseResult1)) {
      return 5;
    } else if (multiTokenMatch(queryLower, toLocaleLowerCaseResult1)) {
      return 3;
    } else {
      if (flag) {
        if (fuzzysearchDefault(queryLower, toLocaleLowerCaseResult1)) {
          return 1;
        }
      }
      return 0;
    }
  } catch (tmp4) {
    logger.error(tmp4);
  }
}
function isValidGuildMember(joinedAt) {
  joinedAt = undefined;
  if (joinedAt != null) {
    joinedAt = joinedAt.joinedAt;
  }
  return null != joinedAt && !joinedAt.isPending;
}
function queryMemberList(allowSnowflake) {
  let boosters;
  let filter;
  let limit;
  let members;
  let num3;
  let num4;
  let num5;
  let num6;
  let query;
  let str6;
  let str7;
  let str8;
  let str9;
  let tmp34;
  let tmp35;
  let tmp38;
  let tmp39;
  ({ query, members, limit, filter, boosters } = allowSnowflake);
  allowSnowflake = allowSnowflake.allowSnowflake;
  const users = UserStore.getUsers();
  const guildId = SelectedGuildStore.getGuildId();
  const toLocaleLowerCaseResult = query.toLocaleLowerCase();
  const normalizer = StringUtils;
  const normalizeResult = normalizer.normalize(toLocaleLowerCaseResult);
  items = [];
  const items1 = [];
  let num = 0;
  let num2 = 0;
  if (0 < members.length) {
    do {
      let str;
      let tmp8;
      let str2;
      let tmp4 = members[num2];
      if (tmp4 instanceof UserRecord) {
        let nick1 = GuildMemberStore.getNick(guildId, tmp4.id);
        let toLocaleLowerCaseResult1;
        if (nick1 != null) {
          toLocaleLowerCaseResult1 = nick1.toLocaleLowerCase();
        }
        str = toLocaleLowerCaseResult1;
        tmp8 = tmp4;
      } else {
        let nick = tmp4.nick;
        if (nick != null) {
          str = nick.toLocaleLowerCase();
        }
        tmp8 = users[tmp4.userId];
      }
      let tmp11 = importDefault;
      let obj2 = UserUtilsDefault;
      let globalName = obj2.getGlobalName(tmp8);
      if (globalName != null) {
        str2 = globalName.toLocaleLowerCase();
      }
      let sum = num;
      if (null != tmp8) {
        if (null == filter) {
          let items2;
          let items3;
          let username = tmp8.username;
          let str3 = username.toLocaleLowerCase();
          let tmp15 = require;
          let obj4 = StringUtils;
          let str4 = obj4.stripDiacritics(str3);
          let normalizer2 = StringUtils;
          let str5 = normalizer2.normalize(str4);
          if (null == str) {
            items2 = [null, null];
          } else {
            let tmp15Result = tmp15(2031);
            let stripDiacriticsResult = tmp15Result.stripDiacritics(str);
            items2 = [stripDiacriticsResult, ];
            let normalizer3 = tmp15(2031);
            items2[1] = normalizer3.normalize(stripDiacriticsResult);
          }
          let tmp17 = _slicedToArray;
          let tmp18 = _slicedToArray(items2, 2);
          [str6, str7] = tmp18;
          if (null == str2) {
            items3 = [null, null];
          } else {
            let tmp15Result2 = tmp15(2031);
            let stripDiacriticsResult1 = tmp15Result2.stripDiacritics(str2);
            items3 = [stripDiacriticsResult1, ];
            let normalizer4 = tmp15(2031);
            items3[1] = normalizer4.normalize(stripDiacriticsResult1);
          }
          let tmp17Result = tmp17(items3, 2);
          [str8, str9] = tmp17Result;
          if (!allowSnowflake) {
            if (str3.substring(0, toLocaleLowerCaseResult.length) !== toLocaleLowerCaseResult) {
              if (str4.substring(0, toLocaleLowerCaseResult.length) !== toLocaleLowerCaseResult) {
                let substr;
                if (str != null) {
                  substr = str.substring(0, toLocaleLowerCaseResult.length);
                }
                if (substr !== toLocaleLowerCaseResult) {
                  let substr1;
                  if (str6 != null) {
                    substr1 = str6.substring(0, toLocaleLowerCaseResult.length);
                  }
                  if (substr1 !== toLocaleLowerCaseResult) {
                    let substr2;
                    if (str2 != null) {
                      substr2 = str2.substring(0, toLocaleLowerCaseResult.length);
                    }
                    if (substr2 !== toLocaleLowerCaseResult) {
                      let substr3;
                      if (str8 != null) {
                        substr3 = str8.substring(0, toLocaleLowerCaseResult.length);
                      }
                      if (substr3 !== toLocaleLowerCaseResult) {
                        if (str5.substring(0, normalizeResult.length) !== normalizeResult) {
                          let substr4;
                          if (str7 != null) {
                            substr4 = str7.substring(0, normalizeResult.length);
                          }
                          if (substr4 !== normalizeResult) {
                            let substr5;
                            if (str9 != null) {
                              substr5 = str9.substring(0, normalizeResult.length);
                            }
                            if (substr5 !== normalizeResult) {
                              let tmp32 = num < 50;
                              if (num < 50) {
                                let tmp27 = tmp11(6095)(toLocaleLowerCaseResult, str4) || tmp11(6095)(normalizeResult, str5);
                                if (!tmp27) {
                                  let tmp28 = null != str6 && tmp11(6095)(toLocaleLowerCaseResult, str6);
                                  tmp27 = tmp28;
                                }
                                if (!tmp27) {
                                  let tmp29 = null != str7 && tmp11(6095)(normalizeResult, str7);
                                  tmp27 = tmp29;
                                }
                                if (!tmp27) {
                                  let tmp30 = null != str8 && tmp11(6095)(toLocaleLowerCaseResult, str8);
                                  tmp27 = tmp30;
                                }
                                if (!tmp27) {
                                  let tmp31 = null != str9 && tmp11(6095)(normalizeResult, str9);
                                  tmp27 = tmp31;
                                }
                                tmp32 = tmp27;
                              }
                              sum = num;
                              if (tmp32) {
                                let obj = { type: AutocompleterResultTypes.USER, record: tmp8, score: 1000 * num3, comparator: tmp34, sortable: tmp35 };
                                num3 = undefined;
                                let push = items1.push;
                                if (boosters != null) {
                                  num3 = boosters[tmp8.id];
                                }
                                if (num3 == null) {
                                  num3 = 1;
                                }
                                tmp34 = str2;
                                if (str2 == null) {
                                  tmp34 = str;
                                }
                                if (tmp34 == null) {
                                  tmp34 = str3;
                                }
                                tmp35 = str8;
                                if (str8 == null) {
                                  tmp35 = str6;
                                }
                                if (tmp35 == null) {
                                  tmp35 = str4;
                                }
                                let arr = push(obj);
                                sum = num + 1;
                              }
                            }
                          }
                        }
                        let obj3 = { type: AutocompleterResultTypes.USER, record: tmp8, score: 1000 * num4, comparator: tmp38, sortable: tmp39 };
                        num4 = undefined;
                        let push2 = items.push;
                        if (boosters != null) {
                          num4 = boosters[tmp8.id];
                        }
                        if (num4 == null) {
                          num4 = 1;
                        }
                        tmp38 = str2;
                        if (str2 == null) {
                          tmp38 = str;
                        }
                        if (tmp38 == null) {
                          tmp38 = str3;
                        }
                        tmp39 = str8;
                        if (str8 == null) {
                          tmp39 = str6;
                        }
                        if (tmp39 == null) {
                          tmp39 = str4;
                        }
                        let push2Result = push2(obj3);
                        sum = num;
                      }
                    }
                  }
                }
              }
            }
          }
          let obj5 = { type: AutocompleterResultTypes.USER, record: tmp8, score: 1000 * num5 * num6, comparator: str2, sortable: str8 };
          num5 = c46;
          num6 = undefined;
          let push3 = items.push;
          if (boosters != null) {
            num6 = boosters[tmp8.id];
          }
          if (num5 === undefined) {
            num5 = 0;
          }
          if (num6 == null) {
            num6 = 1;
          }
          if (str2 == null) {
            str2 = str;
          }
          if (str2 == null) {
            str2 = str3;
          }
          if (str8 == null) {
            str8 = str6;
          }
          if (str8 == null) {
            str8 = str4;
          }
          let push3Result = push3(obj5);
          sum = num;
        } else {
          sum = num;
        }
      }
      num2 = num2 + 1;
      num = sum;
    } while (num2 < members.length);
  }
  const sorted = items.sort(sortByMatchScoreDefault);
  let combined = items;
  if (items.length < limit) {
    const sorted1 = items1.sort(sortByMatchScoreDefault);
    const _Math = Math;
    combined = items.concat(items1.slice(0, Math.max(0, limit - items.length)));
  }
  if (combined.length > limit) {
    combined.length = limit;
  }
  return combined;
}
function getPriorityForStickerMetadataType(arg0) {
  if (StickersTypes.StickerMetadataTypes.STICKER_NAME === arg0) {
    return 11;
  } else if (StickersTypes.StickerMetadataTypes.CORRELATED_EMOJI === arg0) {
    return 6;
  } else if (StickersTypes.StickerMetadataTypes.TAG === arg0) {
    return 1;
  } else {
    if (StickersTypes.StickerMetadataTypes.GUILD_NAME !== arg0) {
      if (StickersTypes.StickerMetadataTypes.PACK_NAME !== arg0) {
        return 1;
      }
    }
    return 8;
  }
}
function isPartialTypeMatch(type, type2) {
  const tmp = type === GUILD_SELECTABLE_CHANNELS_KEY && authStore4(type2);
  return tmp;
}
function getBestScore(toLocaleLowerCaseResult, arr6, flag) {
  let num = 0;
  let tmp = null;
  const iter = arr6[Symbol.iterator]();
  const nextResult = iter.next();
  while (iter !== undefined) {
    let tmp5 = getMatchValue(toLocaleLowerCaseResult, nextResult, flag);
    if (tmp5 > num) {
      num = tmp5;
      tmp = nextResult;
    }
    continue;
  }
  if (null != tmp) {
    if (tmp.isFullMatch) {
      arr6.length = 0;
    } else {
      arr6.splice(arr6.indexOf(tmp), 1);
    }
  }
  return num;
}
function getGuildName(guild_id, arg1) {
  if (null != guild_id.guild_id) {
    let tmp2 = arg1[guild_id.guild_id];
    if (null == tmp2) {
      guild_id = guild_id.guild_id;
      const guild = GuildStore.getGuild(guild_id.guild_id);
      let toLocaleLowerCaseResult;
      if (guild != null) {
        const name = guild.name;
        toLocaleLowerCaseResult = name.toLocaleLowerCase();
      }
      arg1[guild_id] = toLocaleLowerCaseResult;
      tmp2 = toLocaleLowerCaseResult;
    }
    return tmp2;
  }
}
function getCategoryName(parent_id, arg1) {
  if (null != parent_id.parent_id) {
    let tmp2 = arg1[parent_id.parent_id];
    if (null == tmp2) {
      parent_id = parent_id.parent_id;
      const channel = ChannelStore.getChannel(parent_id.parent_id);
      let toLocaleLowerCaseResult;
      if (channel != null) {
        const name = channel.name;
        toLocaleLowerCaseResult = name.toLocaleLowerCase();
      }
      arg1[parent_id] = toLocaleLowerCaseResult;
      tmp2 = toLocaleLowerCaseResult;
    }
    return tmp2;
  }
}
({ InAppNavigationRecord: hasOwnProperty, InAppNavigationType: metroRequire } = InAppNavigationRecord);
({ ChannelRecordBase: map1, isGuildChannelType: closure_14, isGuildSelectableChannelType: closure_15, isGuildVocalChannelType: closure_16, isThread: closure_17, PrivateChannelRecord: closure_18, UnknownChannelRecord: closure_19 } = ChannelRecord);
const isEveryoneRole = GuildRoleRecord.isEveryoneRole;
let GuildChannelStore = GuildChannelStore_mod;
const GUILD_SELECTABLE_CHANNELS_KEY = GuildChannelStore.GUILD_SELECTABLE_CHANNELS_KEY;
const GUILD_VOCAL_CHANNELS_KEY = GuildChannelStore.GUILD_VOCAL_CHANNELS_KEY;
GuildChannelStore = GuildChannelStore_mod;
({ Permissions: closure_38, GuildFeatures: closure_39, ChannelTypes } = Constants);
({ SKUTypes: closure_41, MAX_AUTOCOMPLETE_RESULTS: closure_42 } = Constants);
const AutocompleterResultTypes = autocompleter_AutocompleterConstants.AutocompleterResultTypes;
const StaticChannelId = ChannelConstants.StaticChannelId;
let tmp6 = new LoggerDefault("AutocompleteUtils");
const logger = tmp6;
let c46 = 10;
let tmp7 = /(\t|\s)/;
const re48 = tmp7;
let closure_49 = [];
const MENTION_EVERYONE = utils_AutocompleteUtils.default.MENTION_EVERYONE;
const MENTION_HERE = utils_AutocompleteUtils.default.MENTION_HERE;
const MENTION_GAME = utils_AutocompleteUtils.default.MENTION_GAME;
const MENTION_TIMESTAMP = utils_AutocompleteUtils.default.MENTION_TIMESTAMP;
const LAUNCHABLE_APPLICATIONS = utils_AutocompleteUtils.default.LAUNCHABLE_APPLICATIONS;
class AutocompleteBoostersCache {
  constructor() {
    merged = Object.assign({ lastFrecencyVersion: null, lastRelationshipVersion: null, lastPrivateChannelsVersion: null, cache: null });
    merged[3] = new Map();
    new Map();
    return merged;
  }
  get(arg0) {
    const self = this;
    if (this.isStale()) {
      const cache = self.cache;
      cache.clear();
    }
    const cache2 = self.cache;
    const value = cache2.get(arg0);
    if (null != value) {
      return value;
    } else {
      const buildResult = self.build(arg0);
      const cache3 = self.cache;
      const result = cache3.set(arg0, buildResult);
      return buildResult;
    }
  }
  isStale() {
    const self = this;
    const version = FrecencyStore.getVersion();
    const version1 = RelationshipStore.getVersion();
    const privateChannelsVersion = ChannelStore.getPrivateChannelsVersion();
    let flag = this.lastFrecencyVersion !== version || self.lastRelationshipVersion !== version1 || self.lastPrivateChannelsVersion !== privateChannelsVersion;
    if (flag) {
      self.lastFrecencyVersion = version;
      self.lastRelationshipVersion = version1;
      self.lastPrivateChannelsVersion = privateChannelsVersion;
      flag = true;
    }
    return flag;
  }
  build(arg0) {
    let found;
    const frequentlyWithoutFetchingLatest = FrecencyStore.getFrequentlyWithoutFetchingLatest();
    const reduced = frequentlyWithoutFetchingLatest.reduce((acc, id) => {
      let tmp = acc;
      scoreWithoutFetchingLatest = scoreWithoutFetchingLatest.getScoreWithoutFetchingLatest(id.id);
      if (scoreWithoutFetchingLatest > acc) {
        tmp = scoreWithoutFetchingLatest;
      }
      return tmp;
    }, 0);
    if (AutocompleterResultTypes.GUILD === arg0) {
      found = frequentlyWithoutFetchingLatest.filter((item) => {
        const obj = require("GuildRecordUtils");
        return obj.isGuildRecord(item);
      });
    } else if (AutocompleterResultTypes.USER === arg0) {
      found = frequentlyWithoutFetchingLatest.filter((type) => type instanceof closure_1_13 && type.type === constants.DM);
    } else if (AutocompleterResultTypes.GROUP_DM === arg0) {
      found = frequentlyWithoutFetchingLatest.filter((isMultiUserDM) => {
        const tmp = isMultiUserDM instanceof closure_1_13 && isMultiUserDM.isMultiUserDM();
        return tmp;
      });
    } else if (AutocompleterResultTypes.TEXT_CHANNEL === arg0) {
      found = frequentlyWithoutFetchingLatest.filter((type) => {
        const tmp = type instanceof closure_1_13 && closure_1_15(type.type);
        return tmp;
      });
    } else {
      found = [];
      if (AutocompleterResultTypes.VOICE_CHANNEL === arg0) {
        found = frequentlyWithoutFetchingLatest.filter((isGuildVocal) => {
          const tmp = isGuildVocal instanceof closure_1_13 && isGuildVocal.isGuildVocal();
          return tmp;
        });
      }
    }
    let obj = {};
    const iter = found[Symbol.iterator]();
    const nextResult = iter.next();
    while (iter !== undefined) {
      let obj2 = nextResult;
      let id = nextResult.id;
      let tmp8 = id;
      let scoreWithoutFetchingLatest = FrecencyStore.getScoreWithoutFetchingLatest(id);
      if (arg0 === AutocompleterResultTypes.USER) {
        if (obj2 instanceof authStore5) {
          let type = obj2.type;
          if (ChannelTypes.DM === type) {
            let recipientId = obj2.getRecipientId();
            obj[recipientId] = 1 + scoreWithoutFetchingLatest / reduced;
          } else if (tmp18.GROUP_DM === type) {
            let length = obj2.recipients.length;
            let recipients = obj2.recipients;
            for (const item10068 of recipients) {
              obj[item10068] = 1 + scoreWithoutFetchingLatest / reduced * (1 / length);
              continue;
            }
          }
          continue;
        }
      }
      obj[tmp8] = 1 + scoreWithoutFetchingLatest / reduced;
    }
    const friendIDs = RelationshipStore.getFriendIDs();
    const iter2 = friendIDs[Symbol.iterator]();
    const nextResult1 = iter2.next();
    while (iter2 !== undefined) {
      let num = obj[nextResult1];
      if (num == null) {
        num = 1;
      }
      obj[nextResult1] = num + 0.2;
      continue;
    }
    const dMUserIds = ChannelStore.getDMUserIds();
    const iter3 = dMUserIds[Symbol.iterator]();
    const nextResult2 = iter3.next();
    while (iter3 !== undefined) {
      let num2 = obj[nextResult2];
      if (num2 == null) {
        num2 = 1;
      }
      obj[nextResult2] = num2 + 0.1;
      continue;
    }
    return obj;
  }
}
const prototype = AutocompleteBoostersCache.prototype;
let merged = Object.assign({ lastFrecencyVersion: null, lastRelationshipVersion: null, lastPrivateChannelsVersion: null, cache: null });
const map = new Map();
merged[3] = map;
let items = [GUILD_SELECTABLE_CHANNELS_KEY, GUILD_VOCAL_CHANNELS_KEY, ChannelTypes.GUILD_CATEGORY];
let closure_66 = FunctionUtils.cachedFunction(() => {
  const channelsByRecipientId = new Map();
  const recipientsById = new Map();
  const recipients = [];
  const tmp3 = recipientsById(12);
  const tmp3Result = tmp3(ChannelStore.getMutablePrivateChannels());
  const iter = tmp3Result.values();
  const valueResult = iter.value();
  const item = valueResult.forEach((isDM) => {
    if (isDM.isDM()) {
      const recipientId = isDM.getRecipientId();
      const user = UserStore.getUser(recipientId);
      const hasItem = null == recipientId || null == user || channelsByRecipientId.has(recipientId);
      if (!hasItem) {
        const result = channelsByRecipientId.set(recipientId, isDM);
        const push = recipients.push;
        const obj = { userId: recipientId, nick: RelationshipStore.getNickname(recipientId) };
        push(obj);
        const result1 = recipientsById.set(recipientId, user);
      }
    }
  });
  return { channelsByRecipientId, recipientsById, recipients };
});
let obj = {
  queryFriends(limit) {
    let filter;
    let mapped;
    let user;
    let num = limit.limit;
    const query = limit.query;
    if (num === undefined) {
      num = 10;
    }
    const obj = { query, members: mapped.filter(GlobalUtils.isNotNullish), limit: num, filter };
    filter = limit.filter;
    const friendIDs = RelationshipStore.getFriendIDs();
    mapped = friendIDs.map((item) => user.getUser(item));
    return queryMemberList(obj);
  },
  queryDMUsers(limit) {
    let filter;
    let mapped;
    let user;
    let num = limit.limit;
    const query = limit.query;
    if (num === undefined) {
      num = 10;
    }
    const obj = { query, members: mapped.filter(GlobalUtils.isNotNullish), limit: num, filter };
    filter = limit.filter;
    const dMUserIds = ChannelStore.getDMUserIds();
    mapped = dMUserIds.map((item) => user.getUser(item));
    return queryMemberList(obj);
  },
  queryChannelUsers(channelId) {
    let limit;
    let query;
    ({ query, limit } = channelId);
    channelId = channelId.channelId;
    if (limit === undefined) {
      limit = 10;
    }
    let flag = channelId.request;
    if (flag === undefined) {
      flag = true;
    }
    let flag2 = channelId.checkRecentlyTalkedOnEmptyQuery;
    if (flag2 === undefined) {
      flag2 = true;
    }
    let flag3 = channelId.allowSnowflake;
    if (flag3 === undefined) {
      flag3 = false;
    }
    let channel1;
    let obj = ChannelStore;
    const channel = ChannelStore.getChannel(channelId);
    if (null == channel) {
      return [];
    } else {
      channel1 = null;
      if (channel.isThread()) {
        channel1 = obj.getChannel(channel.parent_id);
      }
      if (channel1 == null) {
        channel1 = channel;
      }
      if (null == channel1) {
        return [];
      } else {
        let tmp6;
        if (channel1.isPrivate()) {
          const recipients = channel1.recipients;
          const mapped = recipients.map((userId) => {
            const obj = { userId, nick: nickname };
            nickname = nickname.getNickname(userId);
            if (nickname == null) {
              nickname = null;
            }
            return obj;
          });
          const currentUser = UserStore.getCurrentUser();
          tmp6 = mapped;
          if (null != currentUser) {
            let obj2 = { userId: currentUser.id, nick: null };
            mapped.push(obj2);
            tmp6 = mapped;
          }
        } else {
          if (0 === query.length) {
            if (flag2) {
              const id = channel.id;
              const channel2 = obj.getChannel(id);
              if (null != id) {
                if (null != channel2) {
                  const tmp16 = _modDef12;
                  const messages = MessageStore.getMessages(id);
                  const tmp16Result = tmp16(messages.toArray());
                  const reversed = tmp16Result.reverse();
                  const uniqByResult = reversed.uniqBy(f92687);
                  const mapped1 = uniqByResult.map(f92688);
                  const found = mapped1.filter((isNonUserBot) => {
                    if (null == isNonUserBot) {
                      return false;
                    } else if (isNonUserBot.isNonUserBot()) {
                      return false;
                    } else {
                      const guildId = channel.getGuildId();
                      let tmp3 = null == guildId;
                      if (!tmp3) {
                        const member = GuildMemberStore.getMember(guildId, isNonUserBot.id);
                        let joinedAt;
                        if (member != null) {
                          joinedAt = member.joinedAt;
                        }
                        tmp3 = null != joinedAt && !member.isPending;
                      }
                      return tmp3;
                    }
                  });
                  const mapped2 = found.map((id) => {
                    let nick;
                    const guildId = channel.getGuildId();
                    let member = null;
                    if (null != guildId) {
                      member = GuildMemberStore.getMember(guildId, id.id);
                    }
                    const obj = { type: AutocompleterResultTypes.USER, record: id, score: 0, comparator: nick };
                    nick = undefined;
                    if (member != null) {
                      nick = member.nick;
                    }
                    if (nick == null) {
                      const obj2 = UserUtilsDefault;
                      nick = obj2.getName(id);
                    }
                    return obj;
                  });
                  const iter = mapped2.take(limit);
                  items = iter.value();
                }
                if (items.length > 0) {
                  return items;
                }
              }
              items = [];
            }
          }
          const members = GuildMemberStore.getMembers(channel1.guild_id);
          const found1 = members.filter(isValidGuildMember);
          tmp6 = found1;
          if (flag) {
            const obj3 = GuildUtilsDefault;
            const members1 = obj3.requestMembers(channel1.guild_id, query, limit);
            tmp6 = found1;
          }
        }
        const obj4 = {
          query,
          members: tmp6,
          limit,
          filter(user) {
                let isPrivateResult = channel1.isPrivate();
                const tmp = channel1;
                if (!isPrivateResult) {
                  const obj2 = { permission: constants.VIEW_CHANNEL, user, context: tmp };
                  const obj = PermissionUtilsAll;
                  isPrivateResult = obj.can(obj2);
                }
                return isPrivateResult;
              },
          allowSnowflake: flag3
        };
        return queryMemberList(obj4);
      }
    }
  },
  queryGuildUsers(request) {
    let allowSnowflake;
    let filter;
    let guildId;
    let limit;
    let query;
    let user;
    ({ guildId, query, limit } = request);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = request.request;
    if (flag === undefined) {
      flag = true;
    }
    let flag2 = request.checkRecentlyTalkedOnEmptyQuery;
    if (flag2 === undefined) {
      flag2 = true;
    }
    ({ filter, allowSnowflake } = request);
    if (null == GuildStore.getGuild(guildId)) {
      return [];
    } else {
      if (0 === query.length) {
        if (flag2) {
          const channelId = SelectedChannelStore.getChannelId(guildId);
          let tmp3 = ChannelStore;
          const channel = ChannelStore.getChannel(channelId);
          if (null != channelId) {
            if (null != channel) {
              const tmp14 = _modDef12;
              const messages = MessageStore.getMessages(channelId);
              const tmp14Result = tmp14(messages.toArray());
              const reversed = tmp14Result.reverse();
              const uniqByResult = reversed.uniqBy(f92687);
              const mapped = uniqByResult.map(f92688);
              const found = mapped.filter((isNonUserBot) => {
                if (null == isNonUserBot) {
                  return false;
                } else if (isNonUserBot.isNonUserBot()) {
                  return false;
                } else {
                  const guildId = channel.getGuildId();
                  let tmp3 = null == guildId;
                  if (!tmp3) {
                    const member = GuildMemberStore.getMember(guildId, isNonUserBot.id);
                    let joinedAt;
                    if (member != null) {
                      joinedAt = member.joinedAt;
                    }
                    tmp3 = null != joinedAt && !member.isPending;
                  }
                  return tmp3;
                }
              });
              const mapped1 = found.map((id) => {
                let nick;
                const guildId = channel.getGuildId();
                let member = null;
                if (null != guildId) {
                  member = GuildMemberStore.getMember(guildId, id.id);
                }
                const obj = { type: AutocompleterResultTypes.USER, record: id, score: 0, comparator: nick };
                nick = undefined;
                if (member != null) {
                  nick = member.nick;
                }
                if (nick == null) {
                  const obj2 = UserUtilsDefault;
                  nick = obj2.getName(id);
                }
                return obj;
              });
              const iter = mapped1.take(limit);
              items = iter.value();
            }
            if (items.length > 0) {
              return items;
            }
          }
          items = [];
        }
      }
      const members = GuildMemberStore.getMembers(guildId);
      const found1 = members.filter(isValidGuildMember);
      if (flag) {
        flag = query.length > 0;
      }
      if (flag) {
        let obj = GuildUtilsDefault;
        const members1 = obj.requestMembers(guildId, query, limit);
      }
      let obj2 = { query, members: found1, limit, filter, allowSnowflake };
      return queryMemberList(obj2);
    }
  },
  queryUsers(limit) {
    let boosters;
    let filter;
    let query;
    let num = limit.limit;
    ({ query, filter, boosters } = limit);
    if (num === undefined) {
      num = 10;
    }
    const obj = { query, members: limit.users, limit: num, filter, allowSnowflake: limit.allowSnowflake, boosters };
    return queryMemberList(obj);
  },
  queryAllUsers(request) {
    let boosters;
    let filter;
    let iter;
    let limit;
    let query;
    ({ query, limit } = request);
    ({ filter, boosters } = request);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = request.request;
    if (flag === undefined) {
      flag = true;
    }
    const tmp = flag && query.length > 0;
    if (tmp) {
      const obj = GuildUtilsDefault;
      const members = obj.requestMembers(null, query, limit);
    }
    const queryUsers = this.queryUsers;
    const obj2 = { query, limit, request: flag, filter, boosters, users: iter.value() };
    const tmp6 = _modDef12;
    const tmp6Result = tmp6(UserStore.getUsers());
    iter = tmp6Result.values();
    return queryUsers(obj2);
  },
  queryChannels(fuzzy) {
    let guildId;
    let limit;
    let obj8;
    let query;
    let valueResult;
    function getSeparatedQueries(query, flag2) {
      let regExp;
      let regExp1;
      let flag = flag2;
      if (flag2 === undefined) {
        flag = false;
      }
      const parts = query.split(" ");
      const found = parts.filter((item) => "" !== item || flag);
      const mapped = found.map((toLocaleLowerCase) => {
        let regExp;
        let regExp1;
        const toLocaleLowerCaseResult = toLocaleLowerCase.toLocaleLowerCase();
        const obj = { queryLower: toLocaleLowerCaseResult, exactQuery: regExp, containQuery: regExp1, isFullMatch: false };
        const obj2 = closure_1_1(closure_1_3[31]);
        regExp = new RegExp("^" + obj2.escape(toLocaleLowerCaseResult), "i");
        const obj3 = closure_1_1(closure_1_3[31]);
        regExp1 = new RegExp(obj3.escape(toLocaleLowerCaseResult), "i");
        return obj;
      });
      if (query.includes(" ")) {
        let toLocaleLowerCaseResult = query.toLocaleLowerCase();
        let obj = { queryLower: toLocaleLowerCaseResult, exactQuery: regExp, containQuery: regExp1, isFullMatch: true };
        const _RegExp = RegExp;
        const unshift = mapped.unshift;
        let obj2 = closure_1(closure_3[31]);
        const _HermesInternal = HermesInternal;
        const self = this;
        const self2 = this;
        const str = obj2.escape(toLocaleLowerCaseResult);
        regExp = new RegExp("^" + str.replace(" ", "( |-)"), "i");
        const _RegExp2 = RegExp;
        let obj3 = closure_1(closure_3[31]);
        const self3 = this;
        const self4 = this;
        const str6 = obj3.escape(toLocaleLowerCaseResult);
        regExp1 = new RegExp(str6.replace(" ", "( |-)"), "i");
        unshift(obj);
      }
      return mapped;
    }
    function includesThreads(type) {
      let tmp = type === GUILD_SELECTABLE_CHANNELS_KEY;
      if (!tmp) {
        tmp = type !== GUILD_VOCAL_CHANNELS_KEY && closure_1_17(type);
        const tmp3 = type !== GUILD_VOCAL_CHANNELS_KEY && closure_1_17(type);
      }
      return tmp;
    }
    ({ query, guildId, limit } = fuzzy);
    if (limit === undefined) {
      limit = closure_42;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    let filter = fuzzy.filter;
    if (filter === undefined) {
      filter = NOOP;
    }
    let type = fuzzy.type;
    if (type === undefined) {
      type = GUILD_SELECTABLE_CHANNELS_KEY;
    }
    let flag2 = fuzzy.allowEmptyQueries;
    if (flag2 === undefined) {
      flag2 = false;
    }
    let flag3 = fuzzy.requireVocalConnectAccess;
    if (flag3 === undefined) {
      flag3 = true;
    }
    let boosters = fuzzy.boosters;
    if (boosters === undefined) {
      boosters = {};
    }
    const allowSnowflake = fuzzy.allowSnowflake;
    const includeAllThreads = fuzzy.includeAllThreads;
    const tmp2 = getSeparatedQueries(query, flag2);
    let tmp3 = includesThreads(type);
    if (null != guildId) {
      const tmp13 = _modDef12;
      const tmp13Result = tmp13(GuildChannelStore.getChannels(guildId)[type]);
      let mapped = tmp13Result.map((channel) => channel.channel);
      const concat2 = mapped.concat;
      if (tmp3) {
        let allThreadsForGuild;
        if (includeAllThreads) {
          allThreadsForGuild = ChannelStore.getAllThreadsForGuild(guildId);
        } else {
          allThreadsForGuild = ActiveJoinedThreadsStore.computeAllActiveJoinedThreads(guildId);
        }
        items = allThreadsForGuild;
      } else {
        items = [];
      }
      const iter2 = concat2(items);
      valueResult = iter2.value();
    } else {
      let allActiveJoinedThreads;
      const tmp6 = _modDef12;
      const tmp6Result = tmp6(ChannelStore.loadAllGuildAndPrivateChannelsFromDisk());
      const values = tmp6Result.values();
      const concat = values.concat;
      if (tmp3) {
        allActiveJoinedThreads = ActiveJoinedThreadsStore.computeAllActiveJoinedThreads();
      } else {
        allActiveJoinedThreads = [];
      }
      const iter = concat(allActiveJoinedThreads);
      valueResult = iter.value();
    }
    let obj = {};
    const items1 = [];
    const maxScore = FrecencyStore.getMaxScore();
    const iter3 = valueResult[Symbol.iterator]();
    const nextResult = iter3.next();
    while (iter3 !== undefined) {
      let obj4 = nextResult;
      let tmp21 = type;
      let type2 = nextResult.type;
      let tmp22 = type2;
      let tmp23 = null != guildId;
      if (type === type2) {
        if (!syncedClientThemes(obj4.type)) {
          if (filter(obj4)) {
            let tmp61;
            let items2 = [];
            let arraySpreadResult = HermesBuiltin.arraySpread(items2, tmp2, 0);
            let arr6 = items2;
            let obj5 = useChannelName;
            let channelName = obj5.computeChannelName(obj4, UserStore, RelationshipStore);
            let toLocaleLowerCaseResult = channelName.toLocaleLowerCase();
            let tmp55 = allowSnowflake;
            if (tmp55) {
              tmp55 = query === obj4.id;
            }
            let tmp57 = tmp55;
            if (tmp57) {
              tmp61 = c46;
            } else {
              tmp61 = getBestScore(toLocaleLowerCaseResult, arr6, flag);
            }
            let sum = tmp61;
            if (0 !== tmp61) {
              if (arr6.length > 0) {
                let items3 = [getGuildName(obj4, obj), ];
                items3[1] = getCategoryName(obj4, obj);
                for (const item10147 of items3) {
                  let tmp64 = item10147;
                  if (null != item10147) {
                    if ("" !== tmp64) {
                      let tmp69 = getBestScore(tmp64, arr6, false);
                      if (0 !== tmp69) {
                        sum = sum + 0.5 * tmp70;
                      }
                    }
                  }
                  continue;
                }
                let _Math = Math;
                sum = Math.min(6, sum);
              }
              if (0 !== sum) {
                if (arr6.length <= 1) {
                  if (1 === arr6.length) {
                  }
                  if (isPartialTypeMatch(type, obj4.type)) {
                    let _Math2 = Math;
                    sum = Math.max(sum - 1, 0.5);
                  }
                  if (obj4.isThread()) {
                    if (!obj4.isActiveThread()) {
                      sum = sum - 3;
                    }
                    if (!JoinedThreadsStore.hasJoined(obj4.id)) {
                      sum = sum - 5;
                    }
                  }
                  let _Math3 = Math;
                  let scoreWithoutFetchingLatest = FrecencyStore.getScoreWithoutFetchingLatest(obj4.id);
                  if (scoreWithoutFetchingLatest == null) {
                    scoreWithoutFetchingLatest = 0 / maxScore;
                  }
                  let num2 = 7;
                  let _Math4 = Math;
                  let min2 = Math.min;
                  let sum1 = sum + 3 * min(scoreWithoutFetchingLatest, 1);
                  if (sum >= 7) {
                    num2 = c46;
                  }
                  let min2Result = min2(sum1, num2);
                  let push = items1.push;
                  let tmp94 = AutocompleterResultTypes;
                  let obj2 = { type: authStore4(obj4.type) ? tmp94.VOICE_CHANNEL : tmp94.TEXT_CHANNEL, record: obj4, score: calculateScore(min2Result, boosters[obj4.id]), comparator: obj8.computeChannelName(obj4, UserStore, RelationshipStore), sortable: toLocaleLowerCaseResult };
                  obj8 = useChannelName;
                  let arr = push(obj2);
                }
              }
            }
          }
        } else {
          let can = PermissionStore.can;
          if (flag3) {
            let VIEW_CHANNEL = obj4.accessPermissions;
          } else {
            VIEW_CHANNEL = constants2.VIEW_CHANNEL;
          }
        }
      } else {
        let tmp24 = tmp23;
        if (tmp24) {
          let tmp31;
          if (tmp21 === GUILD_SELECTABLE_CHANNELS_KEY) {
            let tmp36 = authStore3(tmp22);
            if (!tmp36) {
              tmp36 = authStore4(tmp22);
            }
            tmp31 = tmp36;
          } else {
            tmp31 = tmp21 === GUILD_VOCAL_CHANNELS_KEY;
            if (tmp31) {
              tmp31 = authStore4(tmp22);
            }
          }
        }
      }
      continue;
    }
    const sorted = items1.sort(sortByMatchScoreDefault);
    const tmp105 = null != limit && items1.length > limit;
    if (tmp105) {
      items1.length = limit;
    }
    return items1;
  },
  queryGuilds(fuzzy) {
    let allowSnowflake;
    let filter;
    let limit;
    let query;
    let regExp;
    let regExp1;
    ({ query, limit } = fuzzy);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    ({ filter, allowSnowflake } = fuzzy);
    if (filter === undefined) {
      filter = NOOP;
    }
    let boosters = fuzzy.boosters;
    if (boosters === undefined) {
      boosters = {};
    }
    let str = "";
    if ("" !== query) {
      str = query.toLocaleLowerCase();
    }
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: str };
    const obj3 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj3.escape(str), "i");
    const obj4 = RegexUtilsDefault;
    regExp1 = new RegExp(obj4.escape(str), "i");
    items = [];
    const guildsArray = GuildStore.getGuildsArray();
    const iter = guildsArray[Symbol.iterator]();
    const nextResult = iter.next();
    while (iter !== undefined) {
      let tmp5 = nextResult;
      if (filter(nextResult)) {
        let name = tmp5.name;
        let toLocaleLowerCaseResult = name.toLocaleLowerCase();
        if (allowSnowflake) {
          if (query === tmp5.id) {
            let tmp11 = c46;
            if (tmp11 > 0) {
              let obj2 = { type: AutocompleterResultTypes.GUILD, record: tmp5, score: calculateScore(tmp12, boosters[tmp5.id]), comparator: tmp5.name, sortable: toLocaleLowerCaseResult };
              let push = items.push;
              let arr = push(obj2);
            }
          }
        }
        tmp11 = getMatchValue(toLocaleLowerCaseResult, obj, flag);
      }
      continue;
    }
    const sorted = items.sort(sortByMatchScoreDefault);
    if (items.length > limit) {
      items.length = limit;
    }
    return items;
  },
  queryDMChannels(limit) {
    let _undefined;
    let _undefined2;
    let c0;
    let c1;
    let recipients;
    let num = limit.limit;
    const query = limit.query;
    if (num === undefined) {
      num = 10;
    }
    let boosters = limit.boosters;
    if (boosters === undefined) {
      boosters = {};
    }
    c0 = undefined;
    importDefault = undefined;
    const privateChannelsVersion = ChannelStore.getPrivateChannelsVersion();
    const version = RelationshipStore.getVersion();
    ({ channelsByRecipientId: c0, recipientsById: c1, recipients } = closure_66(privateChannelsVersion, version, UserStore.getUserStoreVersion()));
    let obj = { query, members: recipients, limit: recipients.length, boosters };
    const tmp3 = closure_66(privateChannelsVersion, version, UserStore.getUserStoreVersion());
    items = [];
    const arr = queryMemberList(obj);
    const item = arr.forEach((record) => {
      let obj2;
      const value = _undefined.get(record.record.id);
      if (null != value) {
        const push = items.push;
        const obj = { type: AutocompleterResultTypes.DM, record: value, score: record.score, comparator: obj2.getUserTag(_undefined2.get(record.record.id)), sortable: record.sortable };
        obj2 = UserUtilsDefault;
        push(obj);
      }
    });
    const sorted = items.sort(sortByMatchScoreDefault);
    if (items.length > num) {
      items.length = num;
    }
    return items;
  },
  queryGroupDMs(fuzzy) {
    let limit;
    let obj10;
    let query;
    let regExp;
    let regExp1;
    ({ query, limit } = fuzzy);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    let filter = fuzzy.filter;
    if (filter === undefined) {
      filter = NOOP;
    }
    let boosters = fuzzy.boosters;
    if (boosters === undefined) {
      boosters = {};
    }
    const stripDiacritics = StringUtils.stripDiacritics;
    StringUtils;
    const normalizer = StringUtils;
    const stripDiacriticsResult = stripDiacritics(normalizer.normalize(query.toLocaleLowerCase()));
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: stripDiacriticsResult };
    const obj3 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj3.escape(stripDiacriticsResult), "i");
    const obj4 = RegexUtilsDefault;
    regExp1 = new RegExp(obj4.escape(stripDiacriticsResult), "i");
    const tmp5 = _modDef12;
    const tmp5Result = tmp5(ChannelStore.getMutablePrivateChannels());
    items = [];
    const iter = tmp5Result.values();
    const valueResult = iter.value();
    const iter2 = valueResult[Symbol.iterator]();
    const nextResult = iter2.next();
    while (iter2 !== undefined) {
      let tmp7 = nextResult;
      if (nextResult.isMultiUserDM()) {
        if (filter(tmp7)) {
          let obj7 = useChannelName;
          let channelName = obj7.computeChannelName(tmp7, UserStore, RelationshipStore);
          let toLocaleLowerCaseResult = channelName.toLocaleLowerCase();
          let tmp15 = StringUtils;
          let stripDiacritics2 = tmp15.stripDiacritics;
          let normalizer2 = StringUtils;
          let stripDiacritics2Result = stripDiacritics2(normalizer2.normalize(toLocaleLowerCaseResult));
          let tmp17 = stripDiacritics2Result;
          let tmp19 = getMatchValue(stripDiacritics2Result, obj, flag);
          let items1 = [];
          let recipients = tmp7.recipients;
          for (const item10107 of recipients) {
            let tmp22 = item10107;
            let user = UserStore.getUser(item10107);
            let tmp25 = user;
            if (null != user) {
              let username = tmp25.username;
              let tmp59 = username;
              let obj11 = UserUtilsDefault;
              let globalName = obj11.getGlobalName(tmp25);
              let nickname = RelationshipStore.getNickname(tmp22);
              if (null != username) {
                let arr = items1.push(tmp59);
              }
              if (null != globalName) {
                let arr2 = items1.push(globalName);
              }
              if (null != nickname) {
                let arr6 = items1.push(nickname);
              }
            }
            continue;
          }
          for (const item10133 of items1) {
            let tmp41 = StringUtils;
            let stripDiacritics3 = tmp41.stripDiacritics;
            let normalizer3 = StringUtils;
            let _Math = Math;
            let bound = Math.min(5, getMatchValue(stripDiacritics3(normalizer3.normalize(item10133.toLocaleLowerCase())), obj, flag));
            if (bound > tmp19) {
              tmp19 = bound;
            }
            continue;
          }
          if (tmp19 > 0) {
            let obj2 = { type: AutocompleterResultTypes.GROUP_DM, record: tmp7, score: calculateScore(tmp19, boosters[tmp7.id]), comparator: obj10.computeChannelName(tmp7, UserStore, RelationshipStore), sortable: tmp17 };
            let push = items.push;
            obj10 = useChannelName;
            let arr7 = push(obj2);
          }
        }
      }
      continue;
    }
    const sorted = items.sort(sortByMatchScoreDefault);
    if (items.length > limit) {
      items.length = limit;
    }
    return items;
  },
  queryApplications(fuzzy) {
    let limit;
    let query;
    let regExp;
    let regExp1;
    ({ query, limit } = fuzzy);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    let filter = fuzzy.filter;
    if (filter === undefined) {
      filter = NOOP;
    }
    const toLocaleLowerCaseResult = query.toLocaleLowerCase();
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: toLocaleLowerCaseResult };
    const obj2 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj2.escape(toLocaleLowerCaseResult), "i");
    const obj3 = RegexUtilsDefault;
    regExp1 = new RegExp(obj3.escape(toLocaleLowerCaseResult), "i");
    items = [];
    const tmp4 = LAUNCHABLE_APPLICATIONS();
    const iter = tmp4[Symbol.iterator]();
    while (iter !== undefined) {
      let application = iter.next().application;
      let tmp5 = application;
      if (filter(application)) {
        let name = tmp5.name;
        let toLocaleLowerCaseResult1 = name.toLocaleLowerCase();
        let tmp8 = toLocaleLowerCaseResult1;
        let tmp10 = getMatchValue(toLocaleLowerCaseResult1, obj, flag);
        if (tmp10 > 0) {
          let obj4 = { type: AutocompleterResultTypes.APPLICATION, record: tmp5, score: tmp11, comparator: tmp5.name, sortable: tmp8 };
          let arr = items.push(obj4);
        }
      }
      continue;
    }
    const sorted = items.sort(sortByMatchScoreDefault);
    if (items.length > limit) {
      items.length = limit;
    }
    return items;
  },
  queryInAppNavigations(fuzzy) {
    let limit;
    let query;
    let regExp;
    let regExp1;
    ({ query, limit } = fuzzy);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    const toLocaleLowerCaseResult = query.toLocaleLowerCase();
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: toLocaleLowerCaseResult };
    const obj2 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj2.escape(toLocaleLowerCaseResult), "i");
    const obj3 = RegexUtilsDefault;
    regExp1 = new RegExp(obj3.escape(toLocaleLowerCaseResult), "i");
    const obj4 = {};
    const SHOP = metroRequire.SHOP;
    const intl = intl13.intl;
    items = [intl.string(intl13.t.pWG4ze)];
    obj4[SHOP] = items;
    const SHOP_ORBS_TAB = metroRequire.SHOP_ORBS_TAB;
    const intl2 = intl13.intl;
    const items1 = [intl2.string(intl13.t.ElYQFS), , ];
    const intl3 = intl13.intl;
    items1[1] = intl3.string(intl13.t.pWG4ze);
    const intl4 = intl13.intl;
    items1[2] = intl4.string(intl13.t.EBYkzk);
    obj4[SHOP_ORBS_TAB] = items1;
    const QUEST_ORBS = metroRequire.QUEST_ORBS;
    const intl5 = intl13.intl;
    const items2 = [intl5.string(intl13.t.ElYQFS), , ];
    const intl6 = intl13.intl;
    items2[1] = intl6.string(intl13.t["v/R2aC"]);
    const intl7 = intl13.intl;
    items2[2] = intl7.string(intl13.t.qQR4tn);
    obj4[QUEST_ORBS] = items2;
    const NITRO_HOME = metroRequire.NITRO_HOME;
    const intl8 = intl13.intl;
    const items3 = [intl8.string(intl13.t.Ipxkog)];
    obj4[NITRO_HOME] = items3;
    const QUEST_HOME = metroRequire.QUEST_HOME;
    const intl9 = intl13.intl;
    const items4 = [intl9.string(intl13.t.JALI2K)];
    obj4[QUEST_HOME] = items4;
    const APPS_HOME = metroRequire.APPS_HOME;
    const intl10 = intl13.intl;
    const items5 = [intl10.string(intl13.t.PHjkRE), ];
    const intl11 = intl13.intl;
    items5[1] = intl11.string(intl13.t.AKcFUj);
    obj4[APPS_HOME] = items5;
    const SETTINGS = metroRequire.SETTINGS;
    const intl12 = intl13.intl;
    const items6 = [intl12.string(intl13.t["3D5yo/"])];
    obj4[SETTINGS] = items6;
    const items7 = [];
    for (const key10167 in obj4) {
      let tmp20 = metroRequire[key10167];
      let tmp21 = obj4[tmp20];
      if (null == tmp21) {
        continue;
      } else {
        for (const item10171 of tmp21) {
          let toLocaleLowerCaseResult1 = item10171.toLocaleLowerCase();
          let tmp7 = toLocaleLowerCaseResult1;
          let tmp9 = getMatchValue(toLocaleLowerCaseResult1, obj, flag);
          if (tmp9 > 0) {
            let obj5 = { type: AutocompleterResultTypes.IN_APP_NAVIGATION, record: hasOwnProperty.fromType(tmp20), score: calculateScore(tmp10), comparator: tmp7, sortable: tmp7 };
            let push = items7.push;
            let arr = push(obj5);
          }
          continue;
        }
      }
      continue;
    }
    const sorted = items7.sort(sortByMatchScoreDefault);
    if (items7.length > limit) {
      items7.length = limit;
    }
    return items7;
  },
  querySKUs(fuzzy) {
    let limit;
    let query;
    let regExp;
    let regExp1;
    ({ query, limit } = fuzzy);
    if (limit === undefined) {
      limit = 10;
    }
    let flag = fuzzy.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    let filter = fuzzy.filter;
    if (filter === undefined) {
      filter = NOOP;
    }
    const toLocaleLowerCaseResult = query.toLocaleLowerCase();
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: toLocaleLowerCaseResult };
    const obj2 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj2.escape(toLocaleLowerCaseResult), "i");
    const obj3 = RegexUtilsDefault;
    regExp1 = new RegExp(obj3.escape(toLocaleLowerCaseResult), "i");
    const tmp4 = _modDef12;
    const tmp4Result = tmp4(SKUStore.getSKUs());
    items = [];
    const iter = tmp4Result.values();
    const valueResult = iter.value();
    const iter2 = valueResult[Symbol.iterator]();
    const nextResult = iter2.next();
    while (iter2 !== undefined) {
      let tmp7 = nextResult;
      if (nextResult.type === constants4.DURABLE_PRIMARY) {
        if (filter(tmp7)) {
          let name = tmp7.name;
          let toLocaleLowerCaseResult1 = name.toLocaleLowerCase();
          let tmp12 = toLocaleLowerCaseResult1;
          let tmp14 = getMatchValue(toLocaleLowerCaseResult1, obj, flag);
          if (tmp14 > 0) {
            let obj4 = { type: AutocompleterResultTypes.SKU, record: tmp7, score: tmp15, comparator: tmp7.name, sortable: tmp12 };
            let arr = items.push(obj4);
          }
        }
      }
      continue;
    }
    const sorted = items.sort(sortByMatchScoreDefault);
    if (items.length > limit) {
      items.length = limit;
    }
    return items;
  },
  getRecentlyTalked(channelId1, maxResults) {
    const channel = ChannelStore.getChannel(channelId1);
    if (null != channelId1) {
      if (null != channel) {
        const tmp6 = _modDef12;
        const messages = MessageStore.getMessages(channelId1);
        const tmp6Result = tmp6(messages.toArray());
        const reversed = tmp6Result.reverse();
        const uniqByResult = reversed.uniqBy(f92687);
        const mapped = uniqByResult.map(f92688);
        const found = mapped.filter((isNonUserBot) => {
          if (null == isNonUserBot) {
            return false;
          } else if (isNonUserBot.isNonUserBot()) {
            return false;
          } else {
            const guildId = channel.getGuildId();
            let tmp3 = null == guildId;
            if (!tmp3) {
              const member = GuildMemberStore.getMember(guildId, isNonUserBot.id);
              let joinedAt;
              if (member != null) {
                joinedAt = member.joinedAt;
              }
              tmp3 = null != joinedAt && !member.isPending;
            }
            return tmp3;
          }
        });
        const mapped1 = found.map((id) => {
          let nick;
          const guildId = channel.getGuildId();
          let member = null;
          if (null != guildId) {
            member = GuildMemberStore.getMember(guildId, id.id);
          }
          const obj = { type: AutocompleterResultTypes.USER, record: id, score: 0, comparator: nick };
          nick = undefined;
          if (member != null) {
            nick = member.nick;
          }
          if (nick == null) {
            const obj2 = UserUtilsDefault;
            nick = obj2.getName(id);
          }
          return obj;
        });
        const iter = mapped1.take(maxResults);
        iter.value();
      }
      return [];
    }
  },
  queryMentionResults(canMentionEveryone) {
    let allowSnowflake;
    let channel;
    let query;
    let request;
    ({ query, channel } = canMentionEveryone);
    let flag = canMentionEveryone.canMentionEveryone;
    if (flag === undefined) {
      flag = false;
    }
    let flag2 = canMentionEveryone.canMentionHere;
    if (flag2 === undefined) {
      flag2 = true;
    }
    let flag3 = canMentionEveryone.canMentionUsers;
    if (flag3 === undefined) {
      flag3 = true;
    }
    let flag4 = canMentionEveryone.canMentionRoles;
    if (flag4 === undefined) {
      flag4 = true;
    }
    let flag5 = canMentionEveryone.canMentionOtherGlobals;
    if (flag5 === undefined) {
      flag5 = true;
    }
    let flag6 = canMentionEveryone.includeAllGuildUsers;
    if (flag6 === undefined) {
      flag6 = false;
    }
    let flag7 = canMentionEveryone.includeNonMentionableRoles;
    if (flag7 === undefined) {
      flag7 = false;
    }
    let flag8 = canMentionEveryone.checkRecentlyTalkedOnEmptyQuery;
    if (flag8 === undefined) {
      flag8 = true;
    }
    let limit = canMentionEveryone.limit;
    if (limit === undefined) {
      limit = closure_42;
    }
    ({ allowSnowflake, request } = canMentionEveryone);
    if (allowSnowflake === undefined) {
      allowSnowflake = false;
    }
    let users;
    let closure_7;
    let formatted;
    let substr;
    let guildId;
    let globals;
    if (flag3) {
      const self = this;
      if (flag6) {
        let queryGuildUsersResult;
        let tmp = null;
        if (null != channel.guild_id) {
          const obj2 = { guildId: channel.guild_id, query, limit, checkRecentlyTalkedOnEmptyQuery: flag8, request, allowSnowflake };
          queryGuildUsersResult = self.queryGuildUsers(obj2);
        }
        users = queryGuildUsersResult.map((record) => {
          record = record.record;
          const obj = { user: record, score: record.score, comparator: record.comparator, nick: GuildMemberStore.getNick(channel.guild_id, record.id), status: PresenceStore.getStatus(record.id) };
          return obj;
        });
      }
      let obj = { channelId: channel.id, query, limit, checkRecentlyTalkedOnEmptyQuery: flag8, allowSnowflake };
      queryGuildUsersResult = self.queryChannelUsers(obj);
    } else {
      users = [];
    }
    closure_7 = users.length;
    formatted = query.toLowerCase();
    items = [];
    substr = items;
    let roles = items;
    if (closure_7 < limit) {
      roles = items;
      if (flag4) {
        guildId = channel.getGuildId();
        let tmp5 = GuildStore;
        const guild = GuildStore.getGuild(guildId);
        roles = items;
        if (null != guild) {
          const tmp37 = flag(flag7[37]);
          const tmp37Result = tmp37(GuildRoleStore.getSortedRoles(guild.id));
          const iter = tmp37Result.filter((item) => {
            let id;
            let mentionable;
            let name;
            ({ mentionable, name, id } = item);
            if (!mentionable) {
              mentionable = flag;
            }
            if (!mentionable) {
              mentionable = flag7;
            }
            if (mentionable) {
              const tmp3 = fuzzysearchDefault;
              let tmp3Result = tmp3(formatted, name.toLowerCase());
              if (!tmp3Result) {
                tmp3Result = allowSnowflake && tmp4 === id;
              }
              mentionable = tmp3Result;
            }
            if (mentionable) {
              const obj = SnowflakeUtilsDefault;
              mentionable = id !== obj.castGuildIdAsEveryoneGuildRoleId(guildId);
            }
            return mentionable;
          });
          const obj4 = { keys: ["name"] };
          const valueResult = iter.value();
          const obj3 = channel(flag7[45]);
          const matchSorterResult = obj3.matchSorter(valueResult, query, obj4);
          substr = matchSorterResult.slice(0, limit - closure_7);
          closure_7 = closure_7 + substr.length;
          roles = substr;
        }
      }
    }
    globals = [];
    const tmp9 = !channel.isPrivate() && flag && flag4;
    channel.isPrivate();
    if (tmp9) {
      let tmp14Result = closure_7 < limit;
      if (tmp14Result) {
        const tmp14 = flag(flag7[32]);
        tmp14Result = tmp14(formatted, MENTION_EVERYONE().test);
      }
      if (tmp14Result) {
        let arr = globals.push(MENTION_EVERYONE());
        closure_7 = closure_7 + 1;
      }
      if (flag2) {
        flag2 = closure_7 < limit;
      }
      if (flag2) {
        const tmp22 = flag(flag7[32]);
        flag2 = tmp22(formatted, MENTION_HERE().test);
      }
      if (flag2) {
        let arr2 = globals.push(MENTION_HERE());
        closure_7 = closure_7 + 1;
      }
    }
    function maybePushOtherGlobal(test) {
      const tmp = flag5 && null != test;
      if (tmp) {
        let tmp5 = closure_7 < limit;
        const tmp4 = limit;
        if (!tmp5) {
          tmp5 = 0 === formatted.length;
        }
        if (tmp5) {
          tmp5 = fuzzysearchDefault(formatted, test.test);
        }
        if (!tmp5) {
          tmp5 = formatted === test.test;
        }
        if (tmp5) {
          if (closure_7 >= tmp4) {
            const arr = substr;
            if (substr.length > 0) {
              arr.pop();
            } else {
              const arr2 = users;
              if (users.length > 0) {
                arr2.pop();
              }
            }
          }
          globals.push(test);
          closure_7 = closure_7 + 1;
        }
      }
    }
    const IncludeGameMentionsInAutocomplete = channel(flag7[46]).IncludeGameMentionsInAutocomplete;
    const tmp27 = channel;
    const tmp28 = flag7;
    if (IncludeGameMentionsInAutocomplete.getSetting()) {
      let tmp30;
      if (MENTION_GAME != null) {
        tmp30 = MENTION_GAME();
      }
      maybePushOtherGlobal(tmp30);
    }
    const TimestampAutocompleteMobileExperiment = tmp27(tmp28[47]).TimestampAutocompleteMobileExperiment;
    if (TimestampAutocompleteMobileExperiment.getConfig({ location: "mention autocomplete" }).enabled) {
      let tmp33;
      if (MENTION_TIMESTAMP != null) {
        tmp33 = MENTION_TIMESTAMP();
      }
      maybePushOtherGlobal(tmp33);
    }
    return { users, globals, roles };
  },
  queryGuildMentionResults(canMentionUsers) {
    let canMentionEveryone;
    let guildId;
    let query;
    let status;
    let users;
    ({ query, guildId, canMentionEveryone } = canMentionUsers);
    if (canMentionEveryone === undefined) {
      canMentionEveryone = false;
    }
    let flag = canMentionUsers.canMentionUsers;
    if (flag === undefined) {
      flag = true;
    }
    let flag2 = canMentionUsers.canMentionRoles;
    if (flag2 === undefined) {
      flag2 = true;
    }
    let flag3 = canMentionUsers.canMentionNonMentionableRoles;
    if (flag3 === undefined) {
      flag3 = false;
    }
    let formatted;
    let roles;
    if (flag) {
      const self = this;
      let obj = { guildId, query };
      const queryGuildUsersResult = this.queryGuildUsers(obj);
      users = queryGuildUsersResult.map((record) => {
        const obj = { status: status.getStatus(record.record.id) };
        merged = Object.assign(record);
        return obj;
      });
    } else {
      users = [];
    }
    formatted = query.toLowerCase();
    roles = [];
    let sum = length;
    if (users.length < closure_42) {
      sum = length;
      if (flag2) {
        let tmp4 = GuildStore;
        const guild = GuildStore.getGuild(guildId);
        sum = length;
        if (null != guild) {
          const tmp9 = flag3(roles[37]);
          const tmp9Result = tmp9(GuildRoleStore.getSortedRoles(guild.id));
          const found = tmp9Result.filter((mentionable) => {
            let tmp = mentionable.mentionable || canMentionEveryone || flag3;
            if (tmp) {
              const str = mentionable.name;
              const tmp4 = fuzzysearchDefault;
              tmp = tmp4(formatted, str.toLowerCase());
            }
            if (tmp) {
              tmp = !isEveryoneRole(mentionable);
            }
            return tmp;
          });
          const takeResult = found.take(closure_42 - users.length);
          const item = takeResult.forEach((item) => {
            roles.push(item);
          });
          sum = length + roles.length;
        }
      }
    }
    if (canMentionEveryone) {
      canMentionEveryone = flag2;
    }
    const globals = [];
    if (canMentionEveryone) {
      let tmp15Result = sum < tmp2;
      if (tmp15Result) {
        const tmp15 = flag3(roles[32]);
        tmp15Result = tmp15(formatted, MENTION_EVERYONE().test);
      }
      let sum1 = sum;
      if (tmp15Result) {
        globals.push(MENTION_EVERYONE());
        sum1 = sum + 1;
      }
      let tmp23Result = sum1 < tmp2;
      if (tmp23Result) {
        const tmp23 = flag3(roles[32]);
        tmp23Result = tmp23(formatted, MENTION_HERE().test);
      }
      if (tmp23Result) {
        globals.push(MENTION_HERE());
      }
    }
    return { users, globals, roles };
  },
  queryChoice(choices) {
    let limit;
    let query;
    let queryLower;
    ({ query, limit } = choices);
    choices = choices.choices;
    if (limit === undefined) {
      limit = 10;
    }
    let flag = choices.fuzzy;
    if (flag === undefined) {
      flag = true;
    }
    let regExp1;
    const toLocaleLowerCaseResult = query.toLocaleLowerCase();
    importDefault = toLocaleLowerCaseResult;
    let obj = require("RegexUtils");
    const regExp = new RegExp("^" + obj.escape(toLocaleLowerCaseResult), "i");
    let obj2 = require("RegexUtils");
    regExp1 = new RegExp(obj2.escape(toLocaleLowerCaseResult), "i");
    const arr = require("module_12")(choices);
    const mapped = arr.map((displayName, originalIndex) => {
      displayName = displayName.displayName;
      const obj = { exactQuery: regExp, containQuery: regExp1, queryLower };
      const tmp = getMatchValue(displayName.toLocaleLowerCase(), obj, flag);
      let tmp2 = null;
      if (tmp > 0) {
        tmp2 = { choice: displayName, score: tmp, originalIndex };
        const obj2 = { choice: displayName, score: tmp, originalIndex };
      }
      return tmp2;
    });
    const found = mapped.filter(flag(regExp1[39]).isNotNullish);
    const sortByResult = found.sortBy((score) => -1 * score.score);
    let iter = sortByResult;
    if (null !== limit) {
      iter = sortByResult.take(limit);
    }
    return iter.value();
  },
  queryStaticRouteChannels(arg0) {
    let guild;
    let intl;
    let intl2;
    let intl3;
    let query;
    let regExp;
    let regExp1;
    ({ query, guild } = arg0);
    const toLocaleLowerCaseResult = query.toLocaleLowerCase();
    const obj = { exactQuery: regExp, containQuery: regExp1, queryLower: toLocaleLowerCaseResult };
    const obj2 = RegexUtilsDefault;
    regExp = new RegExp("^" + obj2.escape(toLocaleLowerCaseResult), "i");
    const obj3 = RegexUtilsDefault;
    regExp1 = new RegExp(obj3.escape(toLocaleLowerCaseResult), "i");
    const obj4 = OnboardingHomeUtils;
    let canSeeOnboardingHomeResult = obj4.canSeeOnboardingHome(guild.id);
    if (canSeeOnboardingHomeResult) {
      const features = guild.features;
      canSeeOnboardingHomeResult = !features.has(constants3.HUB);
    }
    const features2 = guild.features;
    const hasItem = features2.has(constants3.COMMUNITY);
    const tmp5Result = useGuildOnboardingAvailable;
    let result = tmp5Result.isGuildOnboardingAvailable(guild);
    const tmp8 = constants3;
    if (result) {
      const features3 = guild.features;
      result = features3.has(tmp8.COMMUNITY);
    }
    const obj5 = { id: StaticChannelId.SERVER_GUIDE, name: intl.string(intl13.t.VbpLyU) };
    intl = tmp5(1126).intl;
    items = [obj5, , ];
    const obj6 = { id: StaticChannelId.CHANNEL_BROWSER, name: intl2.string(intl13.t.et6wav) };
    intl2 = tmp5(1126).intl;
    items[1] = obj6;
    const obj7 = { id: StaticChannelId.CUSTOMIZE_COMMUNITY, name: intl3.string(intl13.t.h9mGOP) };
    intl3 = tmp5(1126).intl;
    items[2] = obj7;
    const items1 = [];
    const iter = items[Symbol.iterator]();
    const nextResult = iter.next();
    while (iter !== undefined) {
      let tmp12 = nextResult;
      let tmp14 = StaticChannelId;
      if (nextResult.id !== StaticChannelId.SERVER_GUIDE) {
        if (tmp12.id !== tmp14.CHANNEL_BROWSER) {
          if (tmp12.id !== tmp14.CUSTOMIZE_COMMUNITY) {
            let name = tmp12.name;
            if (getMatchValue(name.toLocaleLowerCase(), obj, false) > 0) {
              let obj8 = { id: null, name: null, type: ChannelTypes.UNKNOWN, guild_id: guild.id };
              ({ id: obj9.id, name: obj9.name } = tmp12);
              let self = this;
              let self2 = this;
              let push = items1.push;
              let tmp25 = new closure_19(obj8);
              let arr = push(tmp25);
            }
          }
        }
      }
      continue;
    }
    return items1;
  },
  queryChannelResults(query) {
    let channel;
    let queryChannelsResult;
    let type;
    ({ channel, type } = query);
    query = query.query;
    if (type === undefined) {
      type = GUILD_SELECTABLE_CHANNELS_KEY;
    }
    const channelTypes = query.channelTypes;
    let obj = { channels: queryChannelsResult.map((record) => record.record) };
    const obj2 = {
      query,
      guildId: channel.getGuildId(),
      limit: "r",
      fuzzy: "IconComponent",
      filter(type) {
        let hasItem = null == channelTypes;
        const obj = channelTypes;
        if (!hasItem) {
          hasItem = obj.includes(type.type);
        }
        return hasItem;
      },
      type,
      allowEmptyQueries: "function pnpm_useGestureHandlerTs2(event){const{gestureSource,source,state,onChange}=this.__closure;if(gestureSource.value!==source){return;}state.value=event.state;onChange(source,event);}"
    };
    queryChannelsResult = this.queryChannels(obj2);
    return obj;
  },
  queryApplicationCommandChannelResults(limit) {
    let channel;
    let channelTypes;
    const self = this;
    ({ channel, channelTypes } = limit);
    limit = limit.limit;
    const query = limit.query;
    if (limit === undefined) {
      limit = closure_42;
    }
    if (null == channel.guild_id) {
      items = [];
      const tmp11 = null == channelTypes || channelTypes.includes(channel.type);
      if (tmp11) {
        items.push(channel);
      }
      return { channels: items };
    } else {
      let items1 = [];
      for (const item10012 of items) {
        let obj = {
          query,
          guildId: channel.guild_id,
          limit,
          fuzzy: true,
          filter(type) {
                let hasItem = null == channelTypes;
                const obj = channelTypes;
                if (!hasItem) {
                  hasItem = obj.includes(type.type);
                }
                return hasItem;
              },
          type: item10012,
          allowEmptyQueries: true,
          requireVocalConnectAccess: false,
          allowSnowflake: tmp
        };
        items1 = items1.concat(self.queryChannels(obj));
        continue;
      }
      const found = items1.filter((record) => "null" !== record.record.id);
      let sorted = found.sort(compareChannelsByScoreAndPositionDefault);
      const tmp7 = null != limit && sorted.length > limit;
      if (tmp7) {
        sorted = sorted.slice(0, limit);
      }
      const obj3 = { channels: sorted.map((record) => record.record) };
      return obj3;
    }
  },
  queryChoiceResults(query) {
    let queryChoiceResult;
    const obj = { choices: queryChoiceResult.map((choice) => choice.choice) };
    const obj2 = { query: query.query, choices: query.choices, limit: null };
    queryChoiceResult = this.queryChoice(obj2);
    return obj;
  },
  queryEmojiResults(maxCount) {
    let channel;
    let intention;
    let query;
    maxCount = maxCount.maxCount;
    ({ query, channel, intention } = maxCount);
    if (maxCount === undefined) {
      maxCount = closure_42;
    }
    const matchComparator = maxCount.matchComparator;
    const FrecencyUserSettingsActionCreators = UserSettingsProtoActionCreators.FrecencyUserSettingsActionCreators;
    const ifNecessary = FrecencyUserSettingsActionCreators.loadIfNecessary();
    const obj = { emojis: EmojiStore.searchWithoutFetchingLatest({ channel, query, count: maxCount, intention, matchComparator }) };
    return obj;
  },
  queryStickers(items, arg1, items1) {
    let closure_3;
    let nextResult;
    let nextResult1;
    let flag = arg1;
    if (arg1 === undefined) {
      flag = true;
    }
    let tmp = items1;
    if (items1 === undefined) {
      items = [null, NOOP];
      tmp = items;
    }
    [importDefault, ] = tmp;
    let closure_6;
    dependencyMap = UserStore.getCurrentUser();
    set = new Set();
    items1 = [];
    let closure_5 = items1;
    const FrecencyUserSettingsActionCreators = flag(2046).FrecencyUserSettingsActionCreators;
    const ifNecessary = FrecencyUserSettingsActionCreators.loadIfNecessary();
    function _loop() {
      let obj = closure_6;
      if ("" === closure_6) {
        let num = 1;
        return 1;
      } else {
        const toLocaleLowerCaseResult = obj.toLocaleLowerCase();
        flag = toLocaleLowerCaseResult;
        let obj2 = flag(closure_3[33]);
        const stripDiacriticsResult = obj2.stripDiacritics(toLocaleLowerCaseResult);
        const _RegExp = RegExp;
        const _HermesInternal = HermesInternal;
        const self = this;
        const self2 = this;
        const obj3 = require("RegexUtils");
        const regExp = new RegExp("^" + obj3.escape(stripDiacriticsResult), "i");
        let tmp8 = regExp;
        const _RegExp2 = RegExp;
        const _HermesInternal2 = HermesInternal;
        const self3 = this;
        const self4 = this;
        const obj4 = require("RegexUtils");
        const regExp1 = new RegExp("" + obj4.escape(stripDiacriticsResult), "i");
        let tmp10 = regExp1;
        let tmp11 = StickersStore;
        const stickerMetadataArrays = StickersStore.getStickerMetadataArrays();
        let item = stickerMetadataArrays.forEach((arr) => {
          let regex;
          let regex2;
          const item = arr.forEach((item, index) => {
            let num = 0;
            let tmp = null;
            const stickerById = StickersStore.getStickerById(index);
            if (null != stickerById) {
              const obj2 = flag(closure_3[52]);
              if (regExp1(stickerById, obj2.getStickerSendability(stickerById, closure_2_3, regExp))) {
                const iter = item[Symbol.iterator]();
                const iter2 = iter.next();
                while (iter !== undefined) {
                  let type = iter2.type;
                  let tmp7 = type;
                  let value = iter2.value;
                  let tmp9 = getPriorityForStickerMetadataType(type);
                  let num4 = 0;
                  let tmp12 = closure_1_0;
                  if (flag) {
                    if (value === tmp12) {
                      num4 = closure_3_46 * tmp9;
                    } else if (regex.test(value)) {
                      num4 = 7 * tmp9;
                    } else {
                      let tmp15 = flag;
                      let tmp17 = closure_3;
                      let tmp18 = tmp7 !== flag(closure_3[36]).StickerMetadataTypes.GUILD_NAME;
                      if (tmp18) {
                        tmp18 = tmp7 !== tmp15(tmp17[36]).StickerMetadataTypes.PACK_NAME;
                      }
                      if (tmp18) {
                        tmp18 = tmp7 !== tmp15(tmp17[36]).StickerMetadataTypes.STICKER_NAME;
                      }
                      if (!tmp18) {
                        tmp18 = !regex2.test(value);
                      }
                      if (!tmp18) {
                        num4 = 5 * tmp9;
                      }
                    }
                  } else if (value === tmp12) {
                    num4 = closure_3_46 * tmp9;
                    tmp = value;
                  }
                  if (num4 > num) {
                    num = num4;
                    tmp = value;
                  }
                  continue;
                }
                const stickerFrecencyWithoutFetchingLatest = StickersPersistedStore.stickerFrecencyWithoutFetchingLatest;
                const score = stickerFrecencyWithoutFetchingLatest.getScore(index);
                if (null != score) {
                  num = num * (score / 100);
                }
                const tmp37 = num > 0 && null != tmp && !set.has(stickerById.id);
                if (tmp37) {
                  set.add(stickerById.id);
                  const obj = { sticker: stickerById, comparator: tmp, score: num };
                  closure_2_5.push(obj);
                }
              }
            }
          });
        });
      }
    }
    let iter2 = items[Symbol.iterator]();
    while (iter2 !== undefined) {
      closure_6 = iter2.next();
      let _loopResult = _loop();
      continue;
    }
    let obj = _modDef12(items1);
    const iter3 = obj.sortBy((score) => -1 * score.score);
    let valueResult = iter3.value();
    closure_5 = valueResult;
    if (0 === valueResult.length) {
      let tmp11 = closure_49;
      closure_5 = closure_49;
      valueResult = closure_49;
    }
    return valueResult;
  },
  querySoundmoji(arg0, channel) {
    _require = channel;
    const currentUser = UserStore.getCurrentUser();
    const isFetchingResult = SoundboardStore.isFetching();
    const tmp3 = !isFetchingResult && !SoundboardStore.hasFetchedAllSounds();
    if (tmp3) {
      const obj2 = require("SoundboardActionCreators");
      const result = obj2.maybeFetchSoundboardSounds();
    }
    const FrecencyUserSettingsActionCreators = require("UserSettingsProtoActionCreators").FrecencyUserSettingsActionCreators;
    const ifNecessary = FrecencyUserSettingsActionCreators.loadIfNecessary();
    const sounds = obj.getSounds();
    const fromResult = from(sounds.values());
    const reduced = fromResult.reduce((acc, arr) => {
      const item = arr.forEach((item) => {
        let guild_id;
        const tmp = isSoundValidDefault;
        if (acc != null) {
          guild_id = tmp2.guild_id;
        }
        let id;
        if (acc != null) {
          id = tmp2.id;
        }
        if (tmp(item, guild_id, id)) {
          acc.push(item);
        }
      });
      return acc;
    }, []);
    const obj4 = require("searchSounds");
    return obj4.searchSounds(arg0, reduced, currentUser, channel);
  },
  matchSentinel(arg0, arg1, arg2) {
    const isMatch = re48.test(arg1);
    return !isMatch && arg0 === arg2;
  },
  hasSameRoleAsUsername(getGuildId, user) {
    if (user.hasUniqueUsername()) {
      const guild = GuildStore.getGuild(getGuildId.getGuildId());
      if (null != guild) {
        let sortedRoles = GuildRoleStore.getSortedRoles(guild.id);
      } else {
        sortedRoles = [];
      }
      for (const item10019 of sortedRoles) {
        let str = item10019.name;
        let username = user.username;
        if (username.startsWith(str.toLowerCase())) {
          obj.return();
          let flag2 = true;
          return true;
        }
      }
      return false;
    } else {
      return false;
    }
  },
  queryMemberList
};
let result = size.fileFinishedImporting("utils/AutocompleteUtils.tsx");

export default obj;
export const WHITESPACE_REGEX = tmp7;
export { calculateScore };
export const getGameProfileMatchTier = function getGameProfileMatchTier(name, arg1, index) {
  let num2;
  const toLocaleLowerCaseResult = name.toLocaleLowerCase();
  if (toLocaleLowerCaseResult === arg1) {
    num2 = c46;
  } else {
    num2 = 7;
    if (!toLocaleLowerCaseResult.startsWith(arg1)) {
      const _Math = Math;
      num2 = Math.max(1, 7 - index);
    }
  }
  return num2;
};
export const getBoosterMap = function getBoosterMap(USER) {
  return merged.get(USER);
};
export const COMMAND_SUPPORTED_CHANNEL_TYPE_KEYS = items;