// Module ID: 12476
// Function ID: 12477
// Name: ApplicationCommandManager
// Dependencies: [32, 4946, 7831, 1074, 5050, 1607, 12062, 12061, 7829, 7573, 9486, 7575, 9482, 1894, 9376, 4472, 1609, 12225, 12, 12098, 12064, 4592, 12227, 12063, 4573, 4785, 10332, 2]

// Module 12476 (ApplicationCommandManager)
import _modDef12 from "module_12" /* 12 */;
import Server from "Server" /* 1894 */;
import HapticUtils from "HapticUtils" /* 4573 */;
import RegexUtilsDefault from "RegexUtils" /* 4592 */;
import AppAnalyticsUtils from "AppAnalyticsUtils" /* 4785 */;
import ApplicationCommandUtils from "ApplicationCommandUtils" /* 7573 */;
import ApplicationCommandTypes from "ApplicationCommandTypes" /* 7575 */;
import ApplicationCommandActionCreators from "ApplicationCommandActionCreators" /* 7829 */;
import UploadAttachmentActionCreatorsDefault from "UploadAttachmentActionCreators" /* 9376 */;
import ApplicationCommandQueryApiAll from "ApplicationCommandQueryApi" /* 9486 */;
import autocompleter_AutocompleteUtils from "autocompleter/AutocompleteUtils" /* 10332 */;
import ChatInputCommandOptionParser from "ChatInputCommandOptionParser" /* 12061 */;
import ChatInputParser from "ChatInputParser" /* 12062 */;
import ApplicationCommandOptionValueParser from "ApplicationCommandOptionValueParser" /* 12063 */;
import application_commands_ApplicationCommandValidationUtils from "application_commands/ApplicationCommandValidationUtils" /* 12227 */;
import _slicedToArray from "module_32" /* 32 */;
import DraftStore from "DraftStore" /* 4946 */;
import ApplicationCommandStore from "ApplicationCommandStore" /* 7831 */;

const ApplicationCommandActionCreatorsAll = ApplicationCommandActionCreators;

require = fn;
const DraftType = fn(4946).DraftType;
const Constants = fn(1074);
({ AnalyticEvents: closure_8, AutoCompleteResultTypes: closure_9, WHITESPACE_RE: c10 } = Constants);
const ChannelAutocompleteConstants = fn(5050);
({ COMMAND_SENTINEL: closure_11, formatGameMentionRaw: closure_12 } = ChannelAutocompleteConstants);
const MediaKeyboardTarget = fn(1607).MediaKeyboardTarget;
const constants3 = { FULL_COMMAND: 0, [0]: "FULL_COMMAND", PARTIAL_COMMAND: 1, [1]: "PARTIAL_COMMAND" };
const size = fn(2);
let result = size.fileFinishedImporting("modules/application_commands/native/ApplicationCommandManager.tsx");
class ApplicationCommandManager {
  constructor(arg0) {
    obj = Object.create(new.target.prototype);
    closure_0 = obj;
    obj.chatInputNodes = [];
    map = new Map();
    obj.optionsToNodes = map;
    map1 = new Map();
    obj.optionValueNodes = map1;
    map2 = new Map();
    obj.mentionGames = map2;
    map3 = new Map();
    obj.mentionTimestamps = map3;
    tmp5 = new closure_1(closure_3[6])();
    obj.parser = tmp5;
    obj.optionValues = {};
    obj.optionValidationResults = {};
    obj.canAutoInsertFirstOption = true;
    obj.preferredOptionValues = {};
    obj.setAutoCompleteResult = function setAutoCompleteResult(id, addTimestampMentionResult, arg2, type) {
      let insertOrJumpCommandOption = type;
      const activeOption = ApplicationCommandStore.getActiveOption(id);
      if (arg2) {
        if (null != obj.props.activeCommand) {
          if (null != activeOption) {
            if (insertOrJumpCommandOption.type === constants2.GAME_MENTION) {
              return false;
            } else if (insertOrJumpCommandOption.type === tmp4.TIMESTAMP_MENTION) {
              return false;
            } else {
              type = insertOrJumpCommandOption.type;
              if (tmp4.USER === type) {
                const obj3 = { type: "userMention", userId: insertOrJumpCommandOption.user.id };
                let tmp5 = obj3;
                insertOrJumpCommandOption = obj.insertOrJumpCommandOption;
                const obj4 = { displayText: addTimestampMentionResult, preferred: true, value: tmp5 };
                const result = insertOrJumpCommandOption(activeOption, undefined, false, obj4);
              } else if (tmp4.ROLE !== type) {
                if (tmp4.CHANNEL === type) {
                  const obj5 = { type: "channelMention", channelId: insertOrJumpCommandOption.channel.id };
                  tmp5 = obj5;
                }
              }
              const obj6 = { type: "roleMention", roleId: insertOrJumpCommandOption.id };
              tmp5 = obj6;
            }
          }
        }
      }
      if (insertOrJumpCommandOption.type !== constants2.SLASH) {
        return false;
      } else {
        const obj11 = { channelId: id, command: null, section: null, location: null, visualSection: null, query: null, addSpace: true };
        ({ command: obj2.command, section: obj2.section, location: obj2.location, visualSection: obj2.visualSection, query: obj2.query } = insertOrJumpCommandOption);
        obj.setCommand(obj11);
        return true;
      }
    };
    obj.setCommand = function setCommand(arg0) {
      ({ command, query, commandText } = arg0);
      const current = obj.ref.current;
      ({ channelId, section, location: _location, visualSection } = arg0);
      if (commandText == null) {
        const _HermesInternal = HermesInternal;
        let str = "";
        const combined = "" + closure_2_11 + command.displayName;
        if (tmp) {
          str = " ";
        }
        commandText = combined + str;
      }
      current.setText(commandText);
      const obj3 = { channelId, command, section, location: _location, triggerSection: null, queryLength: null };
      const obj2 = ApplicationCommandActionCreators;
      obj3.triggerSection = ApplicationCommandUtils.getCommandTriggerSection(visualSection);
      let length;
      if (query != null) {
        length = query.length;
      }
      obj3.queryLength = length;
      obj2.setActiveCommand(obj3);
      const preferredCommand = obj.preferredCommand;
      let id;
      if (preferredCommand != null) {
        id = preferredCommand.id;
      }
      if (command.id !== id) {
        const obj5 = { preferredCommand: null };
        const obj6 = {};
        const merged = Object.assign(command);
        obj6.preferredCommandType = constants.FULL_COMMAND;
        obj5.preferredCommand = obj6;
        const result = obj.updateApplicationCommandManagerState(obj5);
      }
    };
    obj.setPartialCommand = function setPartialCommand(commandId, commandName, MENTION) {
      const current = obj.ref.current;
      current.setText("" + closure_2_11 + commandName);
      const preferredCommand = obj.preferredCommand;
      let id;
      if (preferredCommand != null) {
        id = preferredCommand.id;
      }
      if (commandId !== id) {
        const obj2 = { preferredCommand: null, location: null };
        const obj3 = { id: commandId, untranslatedName: commandName, displayName: commandName, preferredCommandType: constants.PARTIAL_COMMAND };
        obj2.preferredCommand = obj3;
        obj2.location = MENTION;
        const result = obj.updateApplicationCommandManagerState(obj2);
      }
    };
    obj.setPastedCommand = function setPastedCommand(arg0, channel) {
      const parsed = JSON.parse(arg0);
      obj = ApplicationCommandUtils;
      const result = obj.extractInteractionDataProps(parsed);
      let interactionOptions = result.interactionOptions;
      const cachedCommand = ApplicationCommandQueryApiAll.getCachedCommand({ type: "channel", channel }, result.commandKey);
      ({ application, command } = cachedCommand);
      if (null != command) {
        let tmp8 = null;
        if (null != application) {
          const obj5 = { type: tmp2(7575).ApplicationCommandSectionType.APPLICATION, id: null, icon: null, name: null, application: null };
          ({ id: obj4.id, icon: obj4.icon, bot } = application);
          let username;
          if (bot != null) {
            username = bot.username;
          }
          if (username == null) {
            username = application.name;
          }
          obj5.name = username;
          obj5.application = application;
          tmp8 = obj5;
        }
        if (interactionOptions == null) {
          interactionOptions = [];
        }
        const initialValuesFromInteractionOptions = tmp2(9482).getInitialValuesFromInteractionOptions(command, interactionOptions);
        const _Object = Object;
        const keys = Object.keys(initialValuesFromInteractionOptions);
        const mapped = keys.map((item) => {
          closure_0 = item;
          const options = command.options;
          let found;
          if (options != null) {
            found = options.find((name) => name.name === closure_0);
          }
          const iter = initialValuesFromInteractionOptions[item];
          if (null != found) {
            if (null != iter) {
              let str1;
              if (iter.value != null) {
                str1 = str.toString();
              }
              if (null != found.choices) {
                const choices = found.choices;
                const found1 = choices.find((value) => value.value === iter.value);
                let displayName;
                if (found1 != null) {
                  displayName = found1.displayName;
                }
                str1 = displayName;
              }
              const _HermesInternal = HermesInternal;
              return "" + found.displayName + ":" + str1;
            }
          }
          return null;
        });
        let found = mapped.filter((item) => null != item);
        const joined = found.join(" ");
        const obj6 = { channelId: channel.id, command, section: tmp8, location: tmp2(7575).ApplicationCommandTriggerLocations.PASTE, commandText: null };
        let _HermesInternal = HermesInternal;
        let str2 = "";
        const combined = "" + closure_2_11 + command.displayName;
        if (0 !== joined.length) {
          const _HermesInternal2 = HermesInternal;
          str2 = " " + joined;
        }
        obj6.commandText = combined + str2;
        obj.setCommand(obj6);
        const tmp2Result = tmp2(9482);
      } else {
        ({ id, name } = parsed);
        obj.setPartialCommand(id, name, tmp2(7575).ApplicationCommandTriggerLocations.PASTE);
      }
    };
    obj.updateApplicationCommandManagerState = function updateApplicationCommandManagerState(newState) {
      let props = newState.newState;
      ({ preferredCommand, location: _location } = newState);
      if (props == null) {
        props = obj.props;
      }
      obj = {};
      const merged = Object.assign(props);
      obj.preferredCommand = preferredCommand;
      obj.location = _location;
      obj.mergePropsAndUpdate(obj);
    };
    obj.updateStyles = function updateStyles(styles) {
      obj.styles = styles;
      const chatInputNodes = obj.chatInputNodes;
      obj.chatInputNodes = chatInputNodes.map((style) => {
        if (null == style.style) {
          return style;
        } else {
          const type = style.type;
          if (obj(12062).ChatInputNodeType.COMMAND_OPTION !== type) {
            if (tmp30(12062).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE !== type) {
              if (tmp30(12062).ChatInputNodeType.GAME_HIGHLIGHT === type) {
                const obj2 = {};
                const merged = Object.assign(style);
                const styles4 = closure_1_0.styles;
                obj2.style = styles4.gameMention();
                return obj2;
              } else if (tmp30(12062).ChatInputNodeType.GAME_MENTION_INPUT === type) {
                const obj3 = {};
                const merged1 = Object.assign(style);
                const styles3 = closure_1_0.styles;
                obj3.style = styles3.commandOption();
                return obj3;
              } else if (tmp30(12062).ChatInputNodeType.ROLE_HIGHLIGHT === type) {
                const data = style.data;
                let color;
                if (data != null) {
                  color = data.color;
                }
                const obj4 = {};
                const merged2 = Object.assign(style);
                const styles2 = closure_1_0.styles;
                obj4.style = styles2.autocomplete(color);
                return obj4;
              } else {
                if (tmp30(12062).ChatInputNodeType.EMOJI_HIGHLIGHT !== type) {
                  if (tmp30(12062).ChatInputNodeType.USER_HIGHLIGHT !== type) {
                    if (tmp30(12062).ChatInputNodeType.CHANNEL_HIGHLIGHT !== type) {
                      if (tmp30(12062).ChatInputNodeType.SILENT_HIGHLIGHT !== type) {
                        return style;
                      }
                    }
                  }
                }
                obj = {};
                const merged3 = Object.assign(style);
                const styles = closure_1_0.styles;
                obj.style = styles.autocomplete();
                return obj;
              }
            }
          }
          const data2 = style.data;
          let option;
          if (data2 != null) {
            option = data2.option;
          }
          let tmp19 = null != option;
          if (tmp19) {
            const activeOption = closure_1_0.activeOption;
            let name;
            if (activeOption != null) {
              name = activeOption.name;
            }
            tmp19 = option.name !== name;
          }
          if (tmp19) {
            let success;
            if (closure_1_0.optionValidationResults[option.name] != null) {
              success = tmp23.success;
            }
            tmp19 = false === success;
          }
          const obj5 = {};
          const merged4 = Object.assign(style);
          const styles5 = closure_1_0.styles;
          if (tmp19) {
            let commandErrorOptionResult = styles5.commandErrorOption();
          } else {
            commandErrorOptionResult = styles5.commandOption();
          }
          obj5.style = commandErrorOptionResult;
          return obj5;
        }
      });
      if (obj.chatInputNodes.length > 0) {
        const current = tmp.ref.current;
        const result = current.updateNativeTextBlocksThrottled(tmp.chatInputNodes, tmp.props.editId);
      }
    };
    obj.addCommandOptionParserRules = function addCommandOptionParserRules() {
      const parser = obj.parser;
      obj = {
        ruleId: "commandOptionParserRuleId",
        type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION,
        matchFunction(arg0, arg1) {
          return obj(12061).getMatchedOptions(arg0, arg1);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        deleteNodeOnBackspace: true,
        editDisabled: true
      };
      parser.addRule(obj);
      const parser2 = obj.parser;
      parser2.addRule({
        ruleId: "commandOptionValueParserRuleId",
        type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION_WITH_VALUE,
        matchFunction(arg0, arg1) {
          return obj(12061).getMatchedOptionsWithValue(arg0, arg1);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        editDisabled(data) {
          data = data.data;
          let type;
          if (data != null) {
            type = data.option.type;
          }
          return type === obj(1894).ApplicationCommandOptionType.ATTACHMENT;
        }
      });
      const parser3 = obj.parser;
      const obj2 = {
        ruleId: "commandOptionValueParserRuleId",
        type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION_WITH_VALUE,
        matchFunction(arg0, arg1) {
          return obj(12061).getMatchedOptionsWithValue(arg0, arg1);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        editDisabled(data) {
          data = data.data;
          let type;
          if (data != null) {
            type = data.option.type;
          }
          return type === obj(1894).ApplicationCommandOptionType.ATTACHMENT;
        }
      };
      parser3.addRule({
        ruleId: "emojiHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.EMOJI_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getEmojiHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      });
      const parser4 = obj.parser;
      const obj3 = {
        ruleId: "emojiHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.EMOJI_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getEmojiHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      };
      parser4.addRule({
        ruleId: "roleHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.ROLE_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getRoleHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style(data) {
          data = data.data;
          let color;
          if (data != null) {
            color = data.color;
          }
          const styles = obj.styles;
          return styles.autocomplete(color);
        },
        editDisabled() {
          return false;
        }
      });
      const parser5 = obj.parser;
      const obj4 = {
        ruleId: "roleHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.ROLE_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getRoleHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style(data) {
          data = data.data;
          let color;
          if (data != null) {
            color = data.color;
          }
          const styles = obj.styles;
          return styles.autocomplete(color);
        },
        editDisabled() {
          return false;
        }
      };
      parser5.addRule({
        ruleId: "userHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.USER_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getUsernameHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      });
      const parser6 = obj.parser;
      const obj5 = {
        ruleId: "userHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.USER_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getUsernameHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      };
      parser6.addRule({
        ruleId: "channelHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.CHANNEL_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getChannelHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      });
      const parser7 = obj.parser;
      const obj6 = {
        ruleId: "channelHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.CHANNEL_HIGHLIGHT,
        matchFunction(arg0) {
          obj = obj(12061);
          return obj.getChannelHighlightNodes(closure_1_0.props.channel, arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      };
      parser7.addRule({
        ruleId: "silentHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.SILENT_HIGHLIGHT,
        matchFunction(arg0) {
          return obj(12061).getSilentHighlightNodes(arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      });
      const parser8 = obj.parser;
      const obj7 = {
        ruleId: "silentHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.SILENT_HIGHLIGHT,
        matchFunction(arg0) {
          return obj(12061).getSilentHighlightNodes(arg0);
        },
        style() {
          const styles = obj.styles;
          return styles.autocomplete();
        },
        editDisabled() {
          return false;
        }
      };
      parser8.addRule({
        ruleId: "gameHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.GAME_HIGHLIGHT,
        matchFunction(text) {
          obj = obj(12061);
          return obj.getGameHighlightNodes(closure_1_0.mentionGames, text);
        },
        style() {
          const styles = obj.styles;
          return styles.gameMention();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      });
      const parser9 = obj.parser;
      const obj8 = {
        ruleId: "gameHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.GAME_HIGHLIGHT,
        matchFunction(text) {
          obj = obj(12061);
          return obj.getGameHighlightNodes(closure_1_0.mentionGames, text);
        },
        style() {
          const styles = obj.styles;
          return styles.gameMention();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      };
      parser9.addRule({
        ruleId: "gameMentionInputRuleId",
        type: ChatInputParser.ChatInputNodeType.GAME_MENTION_INPUT,
        matchFunction(arr) {
          return obj(12061).getGameMentionInputNodes(arr);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      });
      const parser10 = obj.parser;
      const obj9 = {
        ruleId: "gameMentionInputRuleId",
        type: ChatInputParser.ChatInputNodeType.GAME_MENTION_INPUT,
        matchFunction(arr) {
          return obj(12061).getGameMentionInputNodes(arr);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      };
      parser10.addRule({
        ruleId: "timestampHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.TIMESTAMP_HIGHLIGHT,
        matchFunction(text) {
          obj = obj(12061);
          return obj.getTimestampHighlightNodes(closure_1_0.mentionTimestamps, text);
        },
        style() {
          const styles = obj.styles;
          return styles.timestampMention();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      });
      const parser11 = obj.parser;
      const obj10 = {
        ruleId: "timestampHighlightRuleId",
        type: ChatInputParser.ChatInputNodeType.TIMESTAMP_HIGHLIGHT,
        matchFunction(text) {
          obj = obj(12061);
          return obj.getTimestampHighlightNodes(closure_1_0.mentionTimestamps, text);
        },
        style() {
          const styles = obj.styles;
          return styles.timestampMention();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      };
      parser11.addRule({
        ruleId: "timestampMentionInputRuleId",
        type: ChatInputParser.ChatInputNodeType.TIMESTAMP_MENTION_INPUT,
        matchFunction(arr) {
          return obj(12061).getTimestampMentionInputNodes(arr);
        },
        style() {
          const styles = obj.styles;
          return styles.commandOption();
        },
        deleteNodeOnBackspace: true,
        editDisabled() {
          return true;
        }
      });
    };
    obj.getCurrentCommand = function getCurrentCommand(text, channel, preferredCommand, preferredCommandSection) {
      let contextCommands = obj;
      if (null != text) {
        if (!obj.props.commandsDisabled) {
          if (text.startsWith(closure_2_11)) {
            obj = ChatInputCommandOptionParser;
            const textBeforeFirstOption = obj.getTextBeforeFirstOption(text);
            ({ match: closure_3, text } = textBeforeFirstOption);
            let flag = false;
            if (null != preferredCommand) {
              const _HermesInternal = HermesInternal;
              if (text.startsWith("" + tmp2 + preferredCommand.displayName)) {
                flag = true;
                if (preferredCommand.preferredCommandType === constants.FULL_COMMAND) {
                  let obj2 = { command: preferredCommand, section: preferredCommandSection };
                  return obj2;
                }
              } else {
                const _HermesInternal2 = HermesInternal;
                flag = false;
              }
            }
            if (null == tmp.contextCommands) {
              return null;
            } else {
              const obj3 = { channel, type: "channel" };
              const commandContext = tmp3(12098).getCommandContext(obj3);
              let preferredCommandType;
              if (preferredCommand != null) {
                preferredCommandType = preferredCommand.preferredCommandType;
              }
              if (preferredCommandType === constants.PARTIAL_COMMAND) {
                contextCommands = tmp.contextCommands;
                let found = contextCommands.find((id) => id.id === preferredCommand.id);
                if (null != found) {
                  const obj4 = { channel, type: "channel" };
                  let cachedApplicationSection = ApplicationCommandQueryApiAll.getCachedApplicationSection(obj4, tmp3(1894).ApplicationCommandType.CHAT, found.applicationId);
                  let tmp20 = null;
                  if (null != cachedApplicationSection) {
                    let obj6 = { command: null, section: null };
                    let obj7 = {};
                    let merged = Object.assign(found);
                    obj7.preferredCommandType = tmp9.FULL_COMMAND;
                    obj6.command = obj7;
                    obj6.section = cachedApplicationSection;
                    tmp20 = obj6;
                  }
                  return tmp20;
                }
              } else {
                const draftCommand = tmp3(12064).resolveDraftCommand(channel, text, DraftStore.getDraftCommand(channel.id, DraftType.ChannelMessage));
                if (null != draftCommand) {
                  const obj8 = { command: null, section: null };
                  const obj9 = {};
                  const merged1 = Object.assign(draftCommand.command);
                  obj9.preferredCommandType = tmp9.FULL_COMMAND;
                  obj8.command = obj9;
                  obj8.section = draftCommand.section;
                  return obj8;
                } else {
                  const parts = text.slice(1).split(" ", 3);
                  c6 = 0;
                  if (0 < parts.length) {
                    function _loop() {
                      const substr = parts.slice(0, parts.length - c6);
                      const joined = substr.join(" ");
                      const obj2 = obj(7573);
                      let tmp = c6;
                      let tmp3 = obj;
                      const regExp = new RegExp("^" + RegexUtilsDefault.escape(joined), "i");
                      const matchingGroupCommands = obj2.getMatchingGroupCommands(contextCommands.contextCommands, regExp, closure_4, 2);
                      const found = matchingGroupCommands.filter((inputType) => {
                        let tmp = inputType.inputType !== joined(dependencyMap[11]).ApplicationCommandInputType.PLACEHOLDER;
                        if (tmp) {
                          tmp = inputType.displayName === joined || inputType.untranslatedName === tmp2;
                          const tmp3 = inputType.displayName === joined || inputType.untranslatedName === tmp2;
                        }
                        return tmp;
                      });
                      if (found.length > 0) {
                        const first = found[0];
                        let tmp7 = tmp > 0;
                        if (!tmp7) {
                          tmp7 = null != dependencyMap;
                        }
                        obj = { channel, type: "channel" };
                        const cachedApplicationSection = ApplicationCommandQueryApiAll.getCachedApplicationSection(obj, tmp3(1894).ApplicationCommandType.CHAT, first.applicationId);
                        if (null == cachedApplicationSection) {
                          let obj5 = { v: null };
                        } else {
                          obj5 = { v: null };
                          const obj6 = { command: null, section: null };
                          const obj7 = {};
                          const merged = Object.assign(first);
                          obj7.preferredCommandType = constants.FULL_COMMAND;
                          obj6.command = obj7;
                          obj6.section = cachedApplicationSection;
                          obj5.v = obj6;
                        }
                        return obj5;
                      }
                      return matchingGroupCommands.length > 0 ? 0 : undefined;
                    }
                    let _loopResult = _loop();
                    let num = 0;
                    if (0 !== _loopResult) {
                      while (!_loopResult) {
                        let sum = num + 1;
                        c6 = sum;
                        if (sum < parts.length) {
                          _loopResult = _loop();
                          num = sum;
                        }
                      }
                      return _loopResult.v;
                    }
                  }
                  const str2 = text.slice(1);
                }
                const tmp3Result2 = tmp3(12064);
              }
              let tmp17 = null;
              if (flag) {
                tmp17 = null;
                if (null != preferredCommand) {
                  const obj10 = { command: preferredCommand, section: null };
                  tmp17 = obj10;
                }
              }
              return tmp17;
            }
          }
        }
      }
      return null;
    };
    obj.getCurrentOption = function getCurrentOption(focused2, selectionStart) {
      closure_0 = selectionStart;
      if (focused2) {
        obj = _modDef12;
        const _Array = Array;
        const optionValueNodes = obj.optionValueNodes;
        const findLastResult = obj.findLast(Array.from(optionValueNodes.values()), (location) => location.location <= closure_0);
        if (findLastResult != null) {
          const data = findLastResult.data;
          if (data != null) {
            const option = data.option;
          }
        }
        if (null != findLastResult) {
          if (null != option) {
            return option;
          }
        }
        return null;
      } else {
        return null;
      }
    };
    obj.getAllCommandOptionValues = function getAllCommandOptionValues(activeCommand, text) {
      if (null == activeCommand.options) {
        return {};
      } else {
        obj = {};
        const optionValueNodes = obj.optionValueNodes;
        const tmp23 = optionValueNodes[Symbol.iterator]();
        while (tmp23 !== undefined) {
          let tmp5 = _slicedToArray(tmp2, 2);
          [tmp6, tmp7] = tmp5;
          let arr = tmp7;
          let data = tmp7.data;
          let type;
          if (data != null) {
            type = data.type;
          }
          if (type === ChatInputParser.ChatInputParseResultDataType.COMMAND_OPTION) {
            let tmp26 = obj.preferredOptionValues[obj.props.channel.id];
            let optionValue;
            let tmp25 = obj;
            if (tmp26 != null) {
              let tmp12 = tmp26[tmp6];
              if (tmp12 != null) {
                optionValue = tmp12.optionValue;
              }
            }
            if (null != optionValue) {
              let items = [tmp14];
              obj[tmp6] = items;
            } else {
              let option = arr.data.option;
              let optionValueParser = tmp25.optionValueParser;
              let items1 = [optionValueParser.parse(text.substring(arr.location + option.displayName.length + 1, arr.location + arr.length), option)];
              obj[tmp6] = items1;
            }
          }
          continue;
        }
        return obj;
      }
    };
    obj.insertFirstOptionIfValid = function insertFirstOptionIfValid(text, activeCommand, displayName, arg3, arg4) {
      if (text.startsWith("" + closure_2_11 + displayName)) {
        if (text.length > displayName.length + 1) {
          if (regex.test(text[displayName.length + 1])) {
            const _Set = Set;
            const optionValueNodes = obj.optionValueNodes;
            const set = new Set(optionValueNodes.keys());
            c1 = true;
            const options = activeCommand.options;
            let found;
            if (options != null) {
              found = options.filter((required) => {
                let tmp = required.required || c1;
                if (tmp) {
                  tmp = !set.has(required.name);
                }
                return tmp;
              });
            }
            let first = null;
            if (null != found) {
              first = null;
              if (found.length > 0) {
                first = found[0];
              }
            }
            if (null != first) {
              const result = obj.insertOrJumpCommandOption(first, activeCommand.displayName.length + 2, true, undefined, activeCommand);
            }
            return true;
          }
        }
      }
      return false;
    };
    obj.insertOrJumpCommandOption = function insertOrJumpCommandOption(found, length, arg2, displayText, activeCommand) {
      let flag = arg2;
      if (arg2 === undefined) {
        flag = false;
      }
      if (activeCommand == null) {
        activeCommand = obj.props.activeCommand;
      }
      if (null != activeCommand) {
        ({ text, selectionStart } = obj.props);
        const optionValueNodes2 = obj.optionValueNodes;
        if (optionValueNodes2 != null) {
          value = optionValueNodes2.get(found.name);
        }
        displayText = undefined;
        if (displayText != null) {
          displayText = displayText.displayText;
        }
        let tmp4 = length;
        if (null == displayText) {
          if (null == value) {
            if (tmp4 == null) {
              tmp4 = selectionStart;
            }
            let tmp27 = null != text && tmp4 <= text.length;
            if (tmp27) {
              const _Math3 = Math;
              tmp27 = !regex.test(text[Math.min(Math, tmp4 - 1, text.length - 1)]);
            }
            const current3 = obj7.ref.current;
            obj = { location: tmp4, length: 0, text: null, nodes: null, keepCursorPosition: null, editId: null };
            let str8 = "";
            if (tmp27) {
              str8 = " ";
            }
            const _HermesInternal6 = HermesInternal;
            obj.text = "" + str8 + found.displayName + ":";
            const obj2 = { type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION, style: null, location: null, length: null };
            const styles3 = obj7.styles;
            obj2.style = styles3.commandOption();
            let num9 = 0;
            if (tmp27) {
              num9 = 1;
            }
            obj2.location = num9;
            obj2.length = found.displayName.length + 1;
            const items = [obj2];
            obj.nodes = items;
            obj.keepCursorPosition = flag;
            obj.editId = obj7.editId;
            current3.replaceRange(obj);
          } else {
            const current2 = obj7.ref.current;
            current2.setSelectedRange(value.location + found.displayName.length + 1, value.length - found.displayName.length - 1);
          }
        } else {
          if (null != value) {
            let _location = value.location;
          } else {
            _location = tmp4;
            if (tmp4 == null) {
              _location = selectionStart;
            }
          }
          let num2 = 0;
          if (null != value) {
            num2 = value.length;
          }
          let tmp5 = null != text && _location <= text.length;
          if (tmp5) {
            const _Math = Math;
            tmp5 = !regex.test(text[Math.min(Math, _location - 1, text.length - 1)]);
          }
          const _Set = Set;
          const optionValueNodes = obj7.optionValueNodes;
          const set = new Set(optionValueNodes.keys());
          set.add(found.name);
          c1 = undefined;
          const options = activeCommand.options;
          found = undefined;
          if (options != null) {
            found = options.filter((required) => {
              let tmp = required.required || c1;
              if (tmp) {
                tmp = !set.has(required.name);
              }
              return tmp;
            });
          }
          let first = null;
          if (null != found) {
            first = null;
            if (found.length > 0) {
              first = found[0];
            }
          }
          let tmp15 = null != displayText;
          if (tmp15) {
            let tmp16 = _location + num2 !== text.length;
            if (tmp16) {
              const _Math2 = Math;
              tmp16 = !regex.test(text[Math.min(Math, _location + num2, text.length - 1)]);
            }
            if (!tmp16) {
              tmp16 = null != first;
            }
            tmp15 = tmp16;
          }
          let displayText1;
          if (displayText != null) {
            displayText1 = displayText.displayText;
          }
          if ("" !== displayText1) {
            const _HermesInternal2 = HermesInternal;
            let combined = "" + found.displayName + ":" + displayText.displayText;
          } else {
            const _HermesInternal = HermesInternal;
            combined = "" + found.displayName + ":";
          }
          let str4 = "";
          if (tmp5) {
            str4 = " ";
          }
          let str5 = "";
          if (tmp15) {
            str5 = " ";
          }
          const _HermesInternal3 = HermesInternal;
          const combined1 = "" + str4 + combined + str5;
          if (null != first) {
            const _HermesInternal4 = HermesInternal;
            const combined2 = "" + first.displayName + ":";
            const _HermesInternal5 = HermesInternal;
            const obj3 = { type: null, style: null, location: null, length: null };
            const combined3 = "" + combined1 + combined2;
            obj3.type = ChatInputParser.ChatInputNodeType.COMMAND_OPTION_WITH_VALUE;
            const styles = obj7.styles;
            obj3.style = styles.commandOption();
            let num6 = 0;
            if (tmp5) {
              num6 = 1;
            }
            obj3.location = num6;
            obj3.length = combined.length;
            const items1 = [obj3, ];
            const obj4 = { type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION, style: null, location: null, length: null };
            const styles2 = obj7.styles;
            obj4.style = styles2.commandOption();
            obj4.location = combined1.length;
            obj4.length = combined2.length;
            items1[1] = obj4;
            const current = obj7.ref.current;
            const obj5 = { location: _location, length: num2, text: combined3, nodes: items1, editId: obj7.editId };
            current.replaceRange(obj5);
          } else {
            const current4 = obj7.ref.current;
            const obj6 = { location: _location, length: num2, text: combined1, nodes: null, keepCursorPosition: null, editId: null };
            const obj8 = { type: ChatInputParser.ChatInputNodeType.COMMAND_OPTION_WITH_VALUE, style: null, location: null, length: null };
            const styles4 = obj7.styles;
            obj8.style = styles4.commandOption();
            let num5 = 0;
            if (tmp5) {
              num5 = 1;
            }
            obj8.location = num5;
            obj8.length = combined.length;
            const items2 = [obj8];
            obj6.nodes = items2;
            obj6.keepCursorPosition = flag;
            obj6.editId = obj7.editId;
            current4.replaceRange(obj6);
          }
        }
        let preferred;
        if (displayText != null) {
          preferred = displayText.preferred;
        }
        if (preferred) {
          const result = obj7.setPreferredOptionValue(obj7.props.channel.id, found.name, displayText);
        }
      }
    };
    obj.sendCommand = function sendCommand(text, channel, fn) {
      const activeCommand = obj.props.activeCommand;
      if (null != activeCommand) {
        let prop = obj.optionValidationResults;
        if (prop == null) {
          prop = {};
        }
        const firstInvalidOption = application_commands_ApplicationCommandValidationUtils.getFirstInvalidOption(activeCommand, prop);
        const obj3 = {};
        const _Object = Object;
        const entries = Object.entries(ApplicationCommandStore.getOptionStates(channel.id));
        const item = entries.forEach((item) => {
          [tmp, tmp2] = item;
          if (null != tmp2.optionValue) {
            obj3[tmp] = tmp2.optionValue;
          }
        });
        if (null == firstInvalidOption) {
          fn(activeCommand, ApplicationCommandOptionValueParser.parseOptionValuesForSend(channel, activeCommand, obj3));
        } else {
          const result = obj.insertOrJumpCommandOption(firstInvalidOption);
          const result1 = obj.updateValidationResults();
          const result2 = HapticUtils.triggerHapticFeedback(HapticUtils.HapticFeedbackTypes.NOTIFICATION_ERROR);
          let applicationId;
          if (activeCommand != null) {
            applicationId = activeCommand.applicationId;
          }
          const obj5 = { application_id: applicationId, command_id: null, argument_type: null, is_required: null };
          let id;
          if (activeCommand != null) {
            const rootCommand = activeCommand.rootCommand;
            if (rootCommand != null) {
              id = rootCommand.id;
            }
          }
          obj5.command_id = id;
          let num2 = firstInvalidOption.type;
          if (num2 == null) {
            num2 = 3;
          }
          obj5.argument_type = Server.ApplicationCommandOptionType[num2];
          let required;
          if (firstInvalidOption != null) {
            required = firstInvalidOption.required;
          }
          obj5.is_required = required;
          AppAnalyticsUtils.trackWithMetadata(constants.APPLICATION_COMMAND_VALIDATION_FAILED, obj5);
        }
        return true;
      } else {
        let query = null;
        if (obj9.getPrefix(text) === closure_2_11) {
          query = autocompleter_AutocompleteUtils.getQuery(text);
        }
        if (null != query) {
          const obj6 = { channel, type: "channel" };
          ({ commands, sections } = ApplicationCommandQueryApiAll.getCachedResults(obj6, Server.ApplicationCommandType.CHAT, query));
          if (null != commands) {
            if (commands.length > 0) {
              if (commands[0].inputType !== ApplicationCommandTypes.ApplicationCommandInputType.PLACEHOLDER) {
                const command = commands[0];
                let found = sections.find((application) => {
                  application = application.application;
                  let id;
                  if (application != null) {
                    id = application.id;
                  }
                  return id === first.applicationId;
                });
                const obj7 = { channelId: channel.id, command, section: null, location: null, query: null };
                if (found == null) {
                  found = null;
                }
                obj7.section = found;
                obj7.location = ApplicationCommandTypes.ApplicationCommandTriggerLocations.DISCOVERY;
                obj7.query = query;
                obj.setCommand(obj7);
                return true;
              }
            }
          }
          const cachedResults = ApplicationCommandQueryApiAll.getCachedResults(obj6, Server.ApplicationCommandType.CHAT, query);
        }
        return false;
      }
    };
    ({ props: obj.props, ref: obj.ref, optionValueParser: obj.optionValueParser, styles: obj.styles } = global);
    result = obj.addCommandOptionParserRules();
    return obj;
  }
}
const prototype = ApplicationCommandManager.prototype;
prototype["addGameMention"] = function addGameMention(game) {
  const mentionGames = this.mentionGames;
  const result = mentionGames.set(game.id, game);
};
prototype["getMentionGames"] = function getMentionGames() {
  return this.mentionGames;
};
prototype["buildGameMentionNode"] = function buildGameMentionNode(game) {
  const obj = { type: ChatInputParser.ChatInputNodeType.GAME_HIGHLIGHT, style: null, deleteNodeOnBackspace: true, editDisabled: true };
  const styles = this.styles;
  obj.style = styles.gameMention();
  const merged = Object.assign(ChatInputCommandOptionParser.buildGameMentionResult(game));
  return obj;
};
prototype["addTimestampMention"] = function addTimestampMention(formatted, mention) {
  const obj = ChatInputCommandOptionParser;
  const result = obj.uniqueTimestampPillText(this.mentionTimestamps, ChatInputCommandOptionParser.formatTimestampPillText(formatted), mention);
  const mentionTimestamps = this.mentionTimestamps;
  const result1 = mentionTimestamps.set(result, mention);
  return result;
};
prototype["getMentionTimestamps"] = function getMentionTimestamps() {
  return this.mentionTimestamps;
};
prototype["clearTimestampMentions"] = function clearTimestampMentions() {
  const mentionTimestamps = this.mentionTimestamps;
  mentionTimestamps.clear();
};
prototype["buildTimestampMentionNode"] = function buildTimestampMentionNode(addTimestampMentionResult) {
  const obj = { type: ChatInputParser.ChatInputNodeType.TIMESTAMP_HIGHLIGHT, style: null, deleteNodeOnBackspace: true, editDisabled: true, location: 0, length: addTimestampMentionResult.length };
  const styles = this.styles;
  obj.style = styles.timestampMention();
  return obj;
};
prototype["setPreferredOptionValue"] = function setPreferredOptionValue(id, name, displayText) {
  const self = this;
  if (null == this.preferredOptionValues[id]) {
    self.preferredOptionValues[id] = {};
  }
  self.preferredOptionValues[id][name] = displayText;
};
prototype["mergePropsAndUpdate"] = function mergePropsAndUpdate(editId) {
  const self = this;
  importDefault = editId;
  const props = this.props;
  ({ text, editId, channel } = props);
  let tmp3 = editId !== editId.editId;
  ({ selectionStart, selectionEnd, focused, queryCommands, lastCommandAutocompleteResponseNonce } = props);
  if (tmp3) {
    tmp3 = null != editId.editId;
  }
  if (tmp3) {
    self.editId = editId.editId;
  }
  importAll = tmp5;
  ({ activeCommand, activeCommandSection: section } = self);
  if (text === editId.text) {
    if (queryCommands === editId.queryCommands) {
      let flag = false;
      let tmp9 = section;
    }
    let id;
    if (activeCommand != null) {
      id = activeCommand.id;
    }
    const activeCommand3 = self.activeCommand;
    let id1;
    if (activeCommand3 != null) {
      id1 = activeCommand3.id;
    }
    let tmp83 = id !== id1;
    dependencyMap = tmp83;
    let activeOption = self.activeOption;
    let currentOption = activeOption;
    let tmp84 = tmp5;
    if (!tmp5) {
      tmp84 = tmp6;
    }
    if (!tmp84) {
      tmp84 = focused !== tmp7;
    }
    if (!tmp84) {
      tmp84 = tmp83;
    }
    if (tmp84) {
      let focused2 = editId.focused;
      if (!focused2) {
        const keyboardType = obj10(4472).getKeyboardType();
        focused2 = keyboardType !== obj10(1609).KeyboardTypes.SYSTEM;
        const obj6 = obj10(4472);
      }
      currentOption = self.getCurrentOption(focused2, editId.selectionStart);
      activeOption = currentOption;
    }
    let tmp91 = tmp83;
    if (tmp83) {
      tmp91 = null != self.activeCommand;
    }
    if (tmp91) {
      UploadAttachmentActionCreatorsDefault.clearAll(channel.id, self.SlashCommand);
    }
    let name1;
    if (activeOption != null) {
      name1 = activeOption.name;
    }
    const activeOption2 = self.activeOption;
    let name3;
    if (activeOption2 != null) {
      name3 = activeOption2.name;
    }
    closure_5 = tmp99;
    let tmp100 = tmp5;
    if (!tmp5) {
      tmp100 = tmp99;
    }
    if (!tmp100) {
      tmp100 = lastCommandAutocompleteResponseNonce !== editId.lastCommandAutocompleteResponseNonce;
    }
    if (tmp100) {
      let preferredCommandType;
      if (activeCommand != null) {
        preferredCommandType = activeCommand.preferredCommandType;
      }
      tmp100 = preferredCommandType === constants3.FULL_COMMAND;
    }
    if (tmp100) {
      self.optionValues = self.getAllCommandOptionValues(activeCommand, editId.text);
      const obj8 = obj10(12225);
      self.optionValidationResults = obj8.getValidationResults(activeCommand, self.optionValues, editId.channel.guild_id, editId.channel.id, false);
      const chatInputNodes = self.chatInputNodes;
      self.chatInputNodes = chatInputNodes.map((type) => {
        if (type.type === ChatInputParser.ChatInputNodeType.COMMAND_OPTION) {
          if (null != type.data) {
            const option = type.data.option;
            if (type.type === tmp(12062).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE) {
              let name;
              if (currentOption != null) {
                name = currentOption.name;
              }
              if (option.name === name) {
                if (closure_2) {
                  const obj = {};
                  const merged = Object.assign(type);
                  obj.style = undefined;
                  return obj;
                }
              }
            }
            const obj2 = {};
            const merged1 = Object.assign(type);
            let name1;
            if (currentOption != null) {
              name1 = currentOption.name;
            }
            if (option.name !== name1) {
              if (undefined !== tmp15) {
                if (!tmp15.success) {
                  const styles = tmp14.styles;
                  obj2.style = styles.commandErrorOption();
                }
                let success;
                if (tmp15 != null) {
                  success = tmp15.success;
                }
                if (success) {
                  success = option.type === tmp(1894).ApplicationCommandOptionType.ATTACHMENT;
                }
                if (success) {
                  const obj3 = { action: "tapAttachment", channelId: editId.channel.id, optionName: option.name };
                  obj2.tapAction = obj3;
                  obj2.deleteNodeOnBackspace = true;
                }
                return obj2;
              }
            }
            const styles2 = tmp14.styles;
            obj2.style = styles2.commandOption();
          }
        }
        return type;
      });
    }
    let tmp109 = tmp5;
    if (!tmp5) {
      tmp109 = tmp83;
    }
    if (!tmp109) {
      tmp109 = tmp99;
    }
    if (!tmp109) {
      tmp109 = editId !== editId.editId;
    }
    if (tmp109) {
      const current = self.ref.current;
      let result = current.updateNativeTextBlocksThrottled(self.chatInputNodes, editId.editId);
    }
    let tmp111 = tmp83;
    if (tmp83) {
      tmp111 = null != activeCommand;
    }
    if (tmp111) {
      self.canAutoInsertFirstOption = true;
    }
    if (!obj9.isEmpty(self.optionsToNodes)) {
      self.canAutoInsertFirstOption = false;
    }
    let preferredCommandType1;
    if (activeCommand != null) {
      preferredCommandType1 = activeCommand.preferredCommandType;
    }
    if (preferredCommandType1 === constants3.FULL_COMMAND) {
      let options;
      if (activeCommand != null) {
        options = activeCommand.options;
      }
      if (options == null) {
        options = [];
      }
      let items = options;
    } else {
      items = [];
    }
    const tmp118 = items.filter((required) => required.required).length > 0;
    let preferredCommandType2;
    if (activeCommand != null) {
      preferredCommandType2 = activeCommand.preferredCommandType;
    }
    if (preferredCommandType2 === constants3.FULL_COMMAND) {
      let options1;
      if (activeCommand != null) {
        options1 = activeCommand.options;
      }
      if (options1 == null) {
        options1 = [];
      }
      let items1 = options1;
    } else {
      items1 = [];
    }
    let canAutoInsertFirstOption = self.canAutoInsertFirstOption;
    if (canAutoInsertFirstOption) {
      let preferredCommandType3;
      if (activeCommand != null) {
        preferredCommandType3 = activeCommand.preferredCommandType;
      }
      canAutoInsertFirstOption = preferredCommandType3 === tmp117.FULL_COMMAND;
    }
    if (canAutoInsertFirstOption) {
      canAutoInsertFirstOption = tmp113(12).isEmpty(self.optionsToNodes);
      const tmp113Result = tmp113(12);
    }
    if (canAutoInsertFirstOption) {
      canAutoInsertFirstOption = editId.text.length >= text.length;
    }
    if (canAutoInsertFirstOption) {
      const tmp123 = 1 === items1.filter((required) => !required.required).length;
      if (!self.insertFirstOptionIfValid(editId.text, activeCommand, activeCommand.displayName, tmp118, tmp123)) {
        let result1 = self.insertFirstOptionIfValid(editId.text, activeCommand, activeCommand.untranslatedName, tmp118, tmp123);
      }
    }
    if (name1 !== name3) {
      let type;
      if (activeOption != null) {
        type = activeOption.type;
      }
      if (type === tmp113(1894).ApplicationCommandOptionType.ATTACHMENT) {
        if (!self.optionValidationResults[activeOption.name].success) {
          const current2 = self.ref.current;
          let obj2 = { type: tmp113(1609).KeyboardTypes.MEDIA, context: null };
          let obj3 = { target: MediaKeyboardTarget.COMMAND, option: activeOption };
          obj2.context = obj3;
          current2.openCustomKeyboard(obj2);
        }
        self.props = editId;
        obj10 = {};
        let preferredCommandType4;
        if (activeCommand != null) {
          preferredCommandType4 = activeCommand.preferredCommandType;
        }
        if (preferredCommandType4 === tmp117.FULL_COMMAND) {
          if (tmp99) {
            if (activeCommand != null) {
              const options2 = activeCommand.options;
              if (options2 != null) {
                const item = options2.forEach((name) => {
                  name = name.name;
                  let name1;
                  if (currentOption != null) {
                    name1 = currentOption.name;
                  }
                  const obj = { isActive: name === name1, optionValue: self.optionValues[name], hasValue: null, location: null, length: null };
                  let tmp4 = null != arr;
                  if (tmp4) {
                    tmp4 = arr.length > 0;
                  }
                  obj.hasValue = tmp4;
                  const optionsToNodes = tmp.optionsToNodes;
                  value = optionsToNodes.get(name);
                  let _location;
                  if (value != null) {
                    _location = value.location;
                  }
                  obj.location = _location;
                  const optionsToNodes2 = tmp.optionsToNodes;
                  value2 = optionsToNodes2.get(name);
                  let length;
                  if (value2 != null) {
                    length = value2.length;
                  }
                  obj.length = length;
                  obj10[name] = obj;
                });
              }
            }
            if (tmp99) {
              if (null != activeOption) {
                obj10[activeOption.name].hasValue = true;
              }
              if (null != self.activeOption) {
                let hasValue;
                if (obj10[self.activeOption.name] != null) {
                  hasValue = tmp150.hasValue;
                }
                if (hasValue) {
                  obj10[self.activeOption.name].lastValidationResult = self.optionValidationResults[self.activeOption.name];
                }
              }
            }
          }
        }
        const currentOption1 = self.getCurrentOption(true, editId.selectionStart);
        if (tmp5) {
          if (null != currentOption1) {
            const name2 = currentOption1.name;
            let obj11 = obj10[name2];
            if (obj11 == null) {
              obj11 = {};
            }
            let optionsToNodes2 = self.optionsToNodes;
            value = optionsToNodes2.get(name2);
            let _location;
            if (value != null) {
              _location = value.location;
            }
            obj11.location = _location;
            const optionsToNodes3 = self.optionsToNodes;
            const value3 = optionsToNodes3.get(name2);
            let length;
            if (value3 != null) {
              length = value3.length;
            }
            obj11.length = length;
            obj11.optionValue = self.optionValues[name2];
            obj11.hasValue = true;
            let success;
            if (self.optionValidationResults[name2] != null) {
              success = tmp156.success;
            }
            if (success) {
              obj11.lastValidationResult = tmp156;
            }
            obj10[name2] = obj11;
          }
        }
        self.activeCommand = activeCommand;
        self.activeCommandSection = tmp9;
        self.activeOption = activeOption;
        if (!tmp83) {
          const _Object = Object;
          tmp83 = Object.keys(obj10).length > 0;
        }
        if (!tmp83) {
          tmp83 = flag;
        }
        if (tmp83) {
          const obj12 = { channelId: editId.channel.id, command: null, section: null, preferredCommandId: null, location: null, changedOptionStates: null };
          const activeCommand4 = self.activeCommand;
          let preferredCommandType5;
          if (activeCommand4 != null) {
            preferredCommandType5 = activeCommand4.preferredCommandType;
          }
          let activeCommand1 = null;
          if (preferredCommandType5 === tmp117.FULL_COMMAND) {
            activeCommand1 = self.activeCommand;
          }
          obj12.command = activeCommand1;
          let activeCommandSection = self.activeCommandSection;
          if (activeCommandSection == null) {
            activeCommandSection = null;
          }
          obj12.section = activeCommandSection;
          const preferredCommand6 = self.preferredCommand;
          let id2;
          if (preferredCommand6 != null) {
            id2 = preferredCommand6.id;
          }
          if (id2 == null) {
            id2 = null;
          }
          obj12.preferredCommandId = id2;
          obj12.location = self.location;
          obj12.changedOptionStates = obj10;
          ApplicationCommandActionCreatorsAll.updateChannelState(obj12);
        }
      }
    }
    let tmp140 = tmp99;
    if (name1 !== name3) {
      tmp140 = null != activeOption;
    }
    if (tmp140) {
      tmp140 = activeOption.type !== tmp113(1894).ApplicationCommandOptionType.ATTACHMENT;
    }
    if (tmp140) {
      const keyboardType1 = tmp113(4472).getKeyboardType();
      tmp140 = keyboardType1 !== tmp113(1609).KeyboardTypes.SYSTEM;
      const tmp113Result2 = tmp113(4472);
    }
    if (tmp140) {
      const current3 = self.ref.current;
      current3.closeCustomKeyboard();
      const current4 = self.ref.current;
      current4.focus();
    }
    obj9 = obj10(12);
  }
  self.contextCommands = editId.queryCommands;
  const preferredCommand = self.preferredCommand;
  if (null != editId.preferredCommand) {
    ({ preferredCommand: self.preferredCommand, location: self.location } = editId);
  }
  if (editId.commandsDisabled) {
    command = null;
    if (null != null) {
      ({ command, section } = null);
    }
    const preferredCommand2 = self.preferredCommand;
    let id3;
    if (preferredCommand2 != null) {
      id3 = preferredCommand2.id;
    }
    let id4;
    if (command != null) {
      id4 = command.id;
    }
    if (id3 !== id4) {
      if (tmp5) {
        self.preferredCommand = null;
        self.preferredCommandSection = null;
        self.location = undefined;
      }
    } else {
      const preferredCommand3 = self.preferredCommand;
      let preferredCommandType6;
      if (preferredCommand3 != null) {
        preferredCommandType6 = preferredCommand3.preferredCommandType;
      }
      let tmp17 = preferredCommandType6 === constants3.PARTIAL_COMMAND;
      if (tmp17) {
        let preferredCommandType7;
        if (command != null) {
          preferredCommandType7 = command.preferredCommandType;
        }
        tmp17 = preferredCommandType7 === tmp16.FULL_COMMAND;
      }
      if (tmp17) {
        self.preferredCommand = command;
      }
    }
    let id5;
    if (preferredCommand != null) {
      id5 = preferredCommand.id;
    }
    const preferredCommand4 = self.preferredCommand;
    let id6;
    if (preferredCommand4 != null) {
      id6 = preferredCommand4.id;
    }
    let tmp21 = id5 !== id6;
    if (!tmp21) {
      let preferredCommandType8;
      if (preferredCommand != null) {
        preferredCommandType8 = preferredCommand.preferredCommandType;
      }
      const preferredCommand5 = self.preferredCommand;
      let preferredCommandType9;
      if (preferredCommand5 != null) {
        preferredCommandType9 = preferredCommand5.preferredCommandType;
      }
      tmp21 = preferredCommandType8 !== preferredCommandType9;
    }
    let obj13 = self.preferredOptionValues[channel.id];
    if (obj13 == null) {
      obj13 = {};
    }
    const parser = self.parser;
    let preferredCommandType10;
    if (command != null) {
      preferredCommandType10 = command.preferredCommandType;
    }
    let tmp26 = null;
    if (preferredCommandType10 === constants3.FULL_COMMAND) {
      tmp26 = command;
    }
    const obj14 = { activeCommand: tmp26, preferredOptionValues: obj13 };
    self.chatInputNodes = parser.parse(editId.text, obj14);
    const mentionGames = self.mentionGames;
    const items2 = [];
    HermesBuiltin.arraySpread(mentionGames.values(), 0);
    const mentionGames2 = self.mentionGames;
    const mapped = items2.map((name) => name.name);
    const tmp31 = mentionGames2[Symbol.iterator]();
    while (tmp31 !== undefined) {
      let tmp36 = currentOption(tmp33, 2);
      let first = tmp36[0];
      let obj4 = obj10(12061);
      let hasItem = 0 !== obj4.findGameMentionTokens(editId.text, tmp36[1].name, mapped).locations.length;
      if (!hasItem) {
        let text2 = editId.text;
        hasItem = text2.includes(closure_12(first));
      }
      if (!hasItem) {
        let mentionGames3 = self.mentionGames;
        let deleteResult = mentionGames3.delete(first);
      }
      continue;
    }
    let optionsToNodes = self.optionsToNodes;
    optionsToNodes.clear();
    let optionValueNodes = self.optionValueNodes;
    optionValueNodes.clear();
    const chatInputNodes1 = self.chatInputNodes;
    const item1 = chatInputNodes1.forEach((type) => {
      if (type.type === ChatInputParser.ChatInputNodeType.COMMAND_OPTION) {
        const data = type.data;
        type = undefined;
        if (data != null) {
          type = data.type;
        }
        if (type === tmp(12062).ChatInputParseResultDataType.COMMAND_OPTION) {
          const optionsToNodes = self.optionsToNodes;
          const result = optionsToNodes.set(type.data.option.name, type);
        }
      }
      let tmp5 = type.type === tmp(12062).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE;
      if (tmp5) {
        const data2 = type.data;
        let type1;
        if (data2 != null) {
          type1 = data2.type;
        }
        tmp5 = type1 === tmp(12062).ChatInputParseResultDataType.COMMAND_OPTION;
      }
      if (tmp5) {
        const optionValueNodes = self.optionValueNodes;
        const result1 = optionValueNodes.set(type.data.option.name, type);
      }
    });
    if (tmp5) {
      const activeCommand2 = self.activeCommand;
      let preferredCommandType11;
      if (activeCommand2 != null) {
        preferredCommandType11 = activeCommand2.preferredCommandType;
      }
      if (preferredCommandType11 === constants3.FULL_COMMAND) {
        const items3 = [];
        const activeCommand5 = self.activeCommand;
        let options3;
        if (activeCommand5 != null) {
          options3 = activeCommand5.options;
        }
        if (options3 == null) {
          options3 = [];
        }
        const iter = options3[Symbol.iterator]();
        const nextResult = iter.next();
        while (iter !== undefined) {
          let tmp56 = nextResult;
          let name = nextResult.name;
          let tmp58 = obj13[name];
          let tmp59 = tmp58;
          let optionValueNodes2 = self.optionValueNodes;
          let tmp57 = name;
          let value4 = optionValueNodes2.get(name);
          let tmp60 = null == tmp58;
          if (!tmp60) {
            tmp60 = "" === tmp59.displayText;
          }
          if (!tmp60) {
            let tmp63 = null != value4;
            if (tmp63) {
              let str2 = editId.text;
              tmp63 = str2.substring(value4.location + tmp56.displayName.length + 1, value4.location + value4.length) === tmp59.displayText;
            }
            tmp60 = tmp63;
          }
          if (!tmp60) {
            delete tmp[tmp2];
            if (tmp56.type === obj10(1894).ApplicationCommandOptionType.ATTACHMENT) {
              let arr = items3.push(tmp57);
            }
          }
          continue;
        }
        if (items3.length > 0) {
          UploadAttachmentActionCreatorsDefault.removeFiles(channel.id, items3, self.SlashCommand);
        }
      }
    }
    self.preferredOptionValues[channel.id] = obj13;
    flag = tmp21;
    tmp9 = section;
    activeCommand = command;
  } else {
    if (!tmp5) {
      if (null != self.preferredCommand) {
        if (self.preferredCommand.preferredCommandType === constants3.FULL_COMMAND) {
          let currentCommand = { command: null, section: null };
          ({ preferredCommand: obj.command, preferredCommandSection: obj.section } = self);
        }
      }
    }
    currentCommand = self.getCurrentCommand(editId.text, editId.channel, self.preferredCommand, self.preferredCommandSection);
  }
};
prototype["updateValidationResults"] = function updateValidationResults() {
  const self = this;
  let obj = {};
  const activeCommand = this.activeCommand;
  let preferredCommandType;
  if (activeCommand != null) {
    preferredCommandType = activeCommand.preferredCommandType;
  }
  if (preferredCommandType === constants3.FULL_COMMAND) {
    const activeCommand2 = self.activeCommand;
    if (activeCommand2 != null) {
      const options = activeCommand2.options;
      if (options != null) {
        const item = options.forEach((name) => {
          name = name.name;
          obj = { lastValidationResult: self.optionValidationResults[name] };
          obj[name] = obj;
        });
      }
    }
  }
  ApplicationCommandActionCreatorsAll.updateOptionStates(self.props.channel.id, obj);
};

export default ApplicationCommandManager;