// Module ID: 4326
// Function ID: 37915
// Name: _isNativeReflectConstruct
// Dependencies: [6, 7, 15, 17, 18, 1910, 3761, 1352, 1348, 1838, 1850, 653, 3771, 4327, 662, 3762, 22, 1360, 686, 21, 566, 2]

// Module 4326 (_isNativeReflectConstruct)
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
import closure_5 from "_callSuper";
import MuteTimers from "MuteTimers";
import hasFlag from "hasFlag";
import dispatcher from "dispatcher";
import closure_9 from "_isNativeReflectConstruct";
import closure_10 from "_isNativeReflectConstruct";
import _callSuper from "_callSuper";
import closure_13 from "_isNativeReflectConstruct";
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
import closure_15 from "_isNativeReflectConstruct";
import ME from "ME";
import { AccountNotificationFlags } from "AccountNotificationFlags";
import { UnreadSetting } from "ReadStateTypes";
import MAX_FAVORITES from "MAX_FAVORITES";
import importDefaultResult from "MuteTimers";
import importDefaultResult1 from "MuteTimers";
import set from "_possibleConstructorReturn";

let closure_11;
let closure_12;
let closure_19;
let closure_20;
const require = arg1;
function _isNativeReflectConstruct() {
  let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {

  }));
  function _isNativeReflectConstruct() {
    return closure_0;
  }
  const result = _isNativeReflectConstruct();
}
function updateUserGuildSettingsInternal(id, channel_overrides) {
  channel_overrides = undefined;
  if (null != dependencyMap[id]) {
    channel_overrides = tmp4.channel_overrides;
  }
  if (null == channel_overrides) {
    channel_overrides = {};
  }
  let obj = {};
  const merged = Object.assign(getGuildDefaults(id));
  const merged1 = Object.assign(tmp4);
  const merged2 = Object.assign(channel_overrides);
  obj["channel_overrides"] = convertChannelOverridesToMap(channel_overrides.channel_overrides);
  importDefaultResult.clearTimer(id);
  const tmp5 = convertChannelOverridesToMap(channel_overrides.channel_overrides);
  const item = importDefault(22).forEach(channel_overrides, (channel_id) => {
    outer1_27.clearTimer(channel_id.channel_id);
  });
  setMuteTimers(id, obj);
  dependencyMap[id] = obj;
  closure_29[id] = mutedChannelsForGuild(dependencyMap[id]);
  const arr = importDefault(22);
  const found = importDefault(22).filter(obj.channel_overrides, (flags) => {
    flags = flags.flags;
    let num = 0;
    if (null != flags) {
      num = flags;
    }
    return outer1_2(outer1_3[17]).hasFlag(num, outer1_19.OPT_IN_ENABLED);
  });
  const arr2 = importDefault(22);
  table[id] = new Set(found.map((channel_id) => channel_id.channel_id));
  if (null != id) {
    const _Set = Set;
    const set1 = new Set(table[id]);
    obj = dependencyMap2[id];
    if (null == obj) {
      obj = {};
    }
    for (const key10063 in obj) {
      let tmp23 = key10063;
      let tmp24 = importAll;
      let tmp25 = dependencyMap;
      let obj5 = importAll(1360);
      let tmp26 = constants;
      if (obj5.hasFlag(obj[key10063].flags, constants.OPT_IN_ENABLED)) {
        let addResult = set1.add(key10063);
        continue;
      } else {
        let deleteResult = set1.delete(key10063);
        continue;
      }
      continue;
    }
    const _Object = Object;
    if (Object.keys(obj).length > 0) {
      closure_34[id] = set1;
    } else {
      delete tmp3[tmp2];
    }
  }
  delete tmp[tmp2];
}
function setMuteTimers(key10030, muted) {
  let closure_0 = key10030;
  if (true === muted.muted) {
    if (importDefaultResult.setTimer(key10030, muted.mute_config, () => {
      outer1_38(closure_0, { muted: false });
      let obj = outer1_1(outer1_3[18]);
      obj = { type: "GUILD_MUTE_EXPIRED", guildId: closure_0 };
      obj.dispatch(obj);
    })) {
      muted.muted = false;
    }
  }
  const item = importDefault(22).forEach(muted.channel_overrides, (muted) => {
    let closure_0 = muted;
    if (true === muted.muted) {
      if (outer1_27.setTimer(muted.channel_id, muted.mute_config, () => {
        outer2_39(muted, muted.channel_id, { muted: false });
        let obj = outer2_1(outer2_3[18]);
        obj = { type: "CHANNEL_MUTE_EXPIRED", guildId: muted, channelId: muted.channel_id };
        obj.dispatch(obj);
      })) {
        muted.muted = false;
      }
    }
  });
}
function updateUserGuildSettings(arg0, arg1) {
  const obj = {};
  let channel_overrides;
  if (null != dependencyMap[arg0]) {
    channel_overrides = tmp.channel_overrides;
  }
  if (null == channel_overrides) {
    channel_overrides = {};
  }
  obj.channel_overrides = channel_overrides;
  const merged = Object.assign(arg1);
  updateUserGuildSettingsInternal(arg0, obj);
}
function updateUserGuildChannelSettings(guildId, channelId, settings) {
  updateMultipleChannels(guildId, { [channelId]: computeNewChannelSettings(guildId, channelId, settings) });
}
function updateUserGuildChannelSettingsBulk(guildId, channel_overrides) {
  let closure_0 = guildId;
  const importDefault = channel_overrides;
  let obj = {};
  obj = null;
  if (null != guildId) {
    obj = dependencyMap2[guildId];
  }
  if (null == obj) {
    obj = {};
  }
  const keys = importDefault(obj[19]).keys(channel_overrides);
  const item = keys.forEach((arg0) => {
    const tmp = outer1_42(closure_0, arg0, table[arg0]);
    obj[arg0] = tmp;
    obj = {};
    const flags = tmp.flags;
    let num = 0;
    if (null != flags) {
      num = flags;
    }
    obj.flags = num;
    obj[arg0] = obj;
  });
  if (null != guildId) {
    obj = {};
    const merged = Object.assign(dependencyMap2[guildId]);
    const merged1 = Object.assign(obj);
    dependencyMap2[guildId] = obj;
  }
  updateMultipleChannels(guildId, obj);
}
function updateMultipleChannels(guildId, arg1) {
  let channel_overrides;
  if (null != dependencyMap[guildId]) {
    channel_overrides = tmp.channel_overrides;
  }
  if (null == channel_overrides) {
    channel_overrides = {};
  }
  let obj = {};
  let tmp3 = arg1;
  if (null != dependencyMap[guildId]) {
    obj = {};
    const merged = Object.assign(channel_overrides);
    const merged1 = Object.assign(arg1);
    tmp3 = obj;
  }
  obj.channel_overrides = tmp3;
  updateUserGuildSettingsInternal(guildId, obj);
}
function computeNewChannelSettings(guildId, channel_id, settings) {
  let channel_overrides;
  if (null != dependencyMap[guildId]) {
    channel_overrides = tmp.channel_overrides;
  }
  if (null == channel_overrides) {
    channel_overrides = {};
  }
  const merged = Object.assign(channel_overrides[channel_id]);
  const merged1 = Object.assign(settings);
  return { channel_id, muted: false };
}
function getGuildDefaults(guildId) {
  guild = guild.getGuild(guildId);
  if (null != guild) {
    let ALL_MESSAGES = guild.defaultMessageNotifications;
  } else {
    ALL_MESSAGES = UserNotificationSettings.ALL_MESSAGES;
  }
  return obj[ALL_MESSAGES];
}
function convertChannelOverridesToMap(channel_overrides) {
  let obj = channel_overrides;
  if (channel_overrides === undefined) {
    obj = {};
  }
  let keyByResult = obj;
  if (obj instanceof Array) {
    keyByResult = importDefault(22).keyBy(obj, "channel_id");
    const obj2 = importDefault(22);
  }
  return keyByResult;
}
function getGuildSettings(guildId) {
  let tmp = dependencyMap[guildId];
  if (null == tmp) {
    tmp = getGuildDefaults(guildId);
  }
  return tmp;
}
function processAccountNotificationSettings(notificationSettings) {
  let closure_23 = importAll(1360).hasFlag(notificationSettings.flags, AccountNotificationFlags.USE_NEW_NOTIFICATIONS);
  const obj = importAll(1360);
  let closure_24 = importAll(1360).hasFlag(notificationSettings.flags, AccountNotificationFlags.MENTION_ON_ALL_MESSAGES);
  let closure_25 = notificationSettings;
}
function mutedChannelsForGuild(channel_overrides) {
  let valueResult = null;
  if (null != channel_overrides.channel_overrides) {
    const found = importDefault(22)(channel_overrides.channel_overrides).filter((mute_config) => outer1_0(outer1_3[15]).computeIsMuted(mute_config));
    const arr = importDefault(22)(channel_overrides.channel_overrides);
    valueResult = found.map((channel_id) => channel_id.channel_id).value();
    const iter = found.map((channel_id) => channel_id.channel_id);
  }
  return new Set(valueResult);
}
function handleGuildUpdate() {
  return true;
}
function shouldUseNewUnreadBehavior() {
  return c23;
}
({ THREAD_CHANNEL_TYPES: closure_11, isPrivate: closure_12 } = _callSuper);
const UserNotificationSettings = ME.UserNotificationSettings;
({ ChannelNotificationSettingsFlags: closure_19, GuildNotificationSettingsFlags: closure_20 } = MAX_FAVORITES);
let closure_21 = {};
let closure_22 = {};
let c23 = false;
let c24 = false;
let closure_25 = { flags: 0 };
importDefaultResult = new importDefaultResult();
importDefaultResult1 = new importDefaultResult1();
let obj = { suppress_everyone: false, suppress_roles: false, mute_scheduled_events: false, mobile_push: true, muted: false, message_notifications: UserNotificationSettings.ALL_MESSAGES, flags: 0, channel_overrides: {}, notify_highlights: ME.HighlightSettings.NULL, hide_muted_channels: false, version: -1, mute_config: null };
obj = {};
obj = {};
let merged = Object.assign(obj);
obj["message_notifications"] = UserNotificationSettings.ALL_MESSAGES;
obj[UserNotificationSettings.ALL_MESSAGES] = obj;
const obj1 = {};
let merged1 = Object.assign(obj);
obj1["message_notifications"] = UserNotificationSettings.ONLY_MENTIONS;
obj[UserNotificationSettings.ONLY_MENTIONS] = obj1;
let closure_29 = {};
let closure_30 = {};
let set = new Set();
let set1 = new Set();
let closure_33 = {};
let closure_34 = {};
let tmp13 = ((PersistedStore) => {
  class UserGuildSettingsStoreClass {
    constructor() {
      self = this;
      tmp = outer1_4(this, UserGuildSettingsStoreClass);
      obj = outer1_7(UserGuildSettingsStoreClass);
      tmp2 = outer1_6;
      if (outer1_35()) {
        tmp6 = globalThis;
        _Reflect = Reflect;
        tmp7 = outer1_7;
        tmp8 = arguments;
        constructResult = Reflect.construct(obj, arguments, outer1_7(self).constructor);
      } else {
        tmp3 = arguments;
        tmp4 = arguments;
        constructResult = obj(...arguments);
      }
      return tmp2(self, constructResult);
    }
  }
  callback2(UserGuildSettingsStoreClass, PersistedStore);
  let obj = {
    key: "initialize",
    value(useNewNotifications) {
      this.waitFor(outer1_13, outer1_14, outer1_9, outer1_10, outer1_15);
      if (null != useNewNotifications) {
        useNewNotifications = useNewNotifications.useNewNotifications;
        const outer1_23 = null != useNewNotifications && useNewNotifications;
        if ("userGuildSettings" in useNewNotifications) {
          const outer1_21 = useNewNotifications.userGuildSettings;
          let prop = useNewNotifications.optedInChannelsByGuild;
          if (null == prop) {
            prop = {};
          }
          const outer1_30 = outer1_1(outer1_3[16]).mapValues(prop, (items) => new Set(items));
          const obj = outer1_1(outer1_3[16]);
          const item = outer1_1(outer1_3[16]).forEach(outer1_21, (arg0, arg1) => {
            outer2_29[arg1] = outer2_47(arg0);
          });
          const arr = outer1_1(outer1_3[16]);
        }
      }
    }
  };
  const items = [obj, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ];
  obj = {
    key: "getState",
    value() {
      return { useNewNotifications: outer1_23 };
    }
  };
  items[1] = obj;
  obj = {
    key: "mentionOnAllMessages",
    get() {
      return outer1_24;
    }
  };
  items[2] = obj;
  items[3] = {
    key: "isSuppressEveryoneEnabled",
    value(arg0) {
      return outer1_45(arg0).suppress_everyone;
    }
  };
  items[4] = {
    key: "isSuppressRolesEnabled",
    value(arg0) {
      return outer1_45(arg0).suppress_roles;
    }
  };
  items[5] = {
    key: "isMuteScheduledEventsEnabled",
    value(arg0) {
      return outer1_45(arg0).mute_scheduled_events;
    }
  };
  items[6] = {
    key: "isMobilePushEnabled",
    value(arg0) {
      return outer1_45(arg0).mobile_push;
    }
  };
  items[7] = {
    key: "isMuted",
    value(arg0) {
      const tmp = outer1_45(arg0);
      return UserGuildSettingsStoreClass(outer1_3[15]).computeIsMuted(tmp);
    }
  };
  items[8] = {
    key: "isTemporarilyMuted",
    value(arg0) {
      const tmp = outer1_45(arg0);
      return UserGuildSettingsStoreClass(outer1_3[15]).isTemporarilyMuted(tmp);
    }
  };
  items[9] = {
    key: "getMuteConfig",
    value(arg0) {
      return outer1_45(arg0).mute_config;
    }
  };
  items[10] = {
    key: "getMessageNotifications",
    value(arg0) {
      return outer1_45(arg0).message_notifications;
    }
  };
  items[11] = {
    key: "getChannelOverrides",
    value(arg0) {
      let channel_overrides = outer1_45(arg0).channel_overrides;
      if (null == channel_overrides) {
        channel_overrides = {};
      }
      return channel_overrides;
    }
  };
  items[12] = {
    key: "getNotifyHighlights",
    value(arg0) {
      return outer1_45(arg0).notify_highlights;
    }
  };
  items[13] = {
    key: "getGuildFlags",
    value(arg0) {
      return outer1_45(arg0).flags;
    }
  };
  items[14] = {
    key: "getChannelMessageNotifications",
    value(arg0, arg1) {
      const tmp = this.getChannelOverrides(arg0)[arg1];
      if (null != tmp) {
        if (null != tmp.message_notifications) {
          let NULL = tmp.message_notifications;
        }
        return NULL;
      }
      NULL = outer1_16.NULL;
    }
  };
  items[15] = {
    key: "getChannelMuteConfig",
    value(arg0, arg1) {
      const tmp = this.getChannelOverrides(arg0)[arg1];
      let mute_config = null;
      if (null != tmp) {
        mute_config = tmp.mute_config;
      }
      return mute_config;
    }
  };
  items[16] = {
    key: "getMutedChannels",
    value(arg0) {
      let tmp = outer1_29[arg0];
      if (null == tmp) {
        tmp = outer1_31;
      }
      return tmp;
    }
  };
  items[17] = {
    key: "isChannelMuted",
    value(arg0, channelId) {
      let tmp = arg0;
      const self = this;
      const channel = outer1_13.getChannel(channelId);
      let guildId;
      if (null != channel) {
        guildId = channel.getGuildId();
      }
      if (null != guildId) {
        tmp = guildId;
      }
      const mutedChannels = self.getMutedChannels(tmp);
      return mutedChannels.has(channelId);
    }
  };
  items[18] = {
    key: "isCategoryMuted",
    value(arg0, channelId) {
      const self = this;
      const channel = outer1_13.getChannel(channelId);
      if (null == channel) {
        return false;
      } else {
        const parent_id = channel.parent_id;
        let hasItem = null != parent_id;
        if (hasItem) {
          const mutedChannels = self.getMutedChannels(arg0);
          hasItem = mutedChannels.has(parent_id);
        }
        return hasItem;
      }
    }
  };
  items[19] = {
    key: "resolvedMessageNotifications",
    value(guild_id) {
      const self = this;
      const channelMessageNotifications = this.getChannelMessageNotifications(guild_id.guild_id, guild_id.id);
      if (channelMessageNotifications !== outer1_16.NULL) {
        return channelMessageNotifications;
      } else {
        if (null != guild_id.parent_id) {
          const channelMessageNotifications1 = self.getChannelMessageNotifications(guild_id.guild_id, guild_id.parent_id);
          if (channelMessageNotifications1 !== outer1_16.NULL) {
            return channelMessageNotifications1;
          }
        }
        return self.getMessageNotifications(guild_id.guild_id);
      }
    }
  };
  items[20] = {
    key: "resolveUnreadSetting",
    value(type) {
      const self = this;
      if (outer1_11.has(type.type)) {
        return outer1_18.ALL_MESSAGES;
      } else if (outer1_12(type.type)) {
        return outer1_18.ALL_MESSAGES;
      } else if (outer1_48()) {
        const channelUnreadSetting = self.getChannelUnreadSetting(type.guild_id, type.id);
        if (channelUnreadSetting !== outer1_18.UNSET) {
          return channelUnreadSetting;
        } else {
          if (null != type.parent_id) {
            const channelUnreadSetting1 = self.getChannelUnreadSetting(type.guild_id, type.parent_id);
            if (channelUnreadSetting1 !== outer1_18.UNSET) {
              return channelUnreadSetting1;
            }
          }
          const guildUnreadSetting = self.getGuildUnreadSetting(type.guild_id);
          if (guildUnreadSetting !== outer1_18.UNSET) {
            return guildUnreadSetting;
          } else if (self.resolvedMessageNotifications(type) === outer1_16.ALL_MESSAGES) {
            let ONLY_MENTIONS = outer1_18.ALL_MESSAGES;
          } else {
            ONLY_MENTIONS = outer1_18.ONLY_MENTIONS;
          }
        }
      } else {
        return outer1_18.ALL_MESSAGES;
      }
    }
  };
  items[21] = {
    key: "isGuildOrCategoryOrChannelMuted",
    value(id) {
      const self = this;
      return this.isMuted(id) || self.isCategoryMuted(id, arg1) || self.isChannelMuted(id, arg1);
    }
  };
  items[22] = {
    key: "allowNoMessages",
    value(guild_id) {
      const self = this;
      let result = this.isGuildOrCategoryOrChannelMuted(guild_id.guild_id, guild_id.id);
      if (!result) {
        result = self.resolvedMessageNotifications(guild_id) === outer1_16.NO_MESSAGES;
      }
      if (!result) {
        result = self.isOptInEnabled(guild_id.guild_id) && !self.isChannelRecordOrParentOptedIn(guild_id);
        const tmp3 = self.isOptInEnabled(guild_id.guild_id) && !self.isChannelRecordOrParentOptedIn(guild_id);
      }
      return result;
    }
  };
  items[23] = {
    key: "allowAllMessages",
    value(guild_id) {
      const self = this;
      let tmp = !this.isGuildOrCategoryOrChannelMuted(guild_id.guild_id, guild_id.id);
      if (tmp) {
        tmp = self.resolvedMessageNotifications(guild_id) === outer1_16.ALL_MESSAGES;
      }
      if (tmp) {
        tmp = !self.isOptInEnabled(guild_id.guild_id) || self.isChannelRecordOrParentOptedIn(guild_id);
        const tmp3 = !self.isOptInEnabled(guild_id.guild_id) || self.isChannelRecordOrParentOptedIn(guild_id);
      }
      return tmp;
    }
  };
  items[24] = {
    key: "isGuildCollapsed",
    value(arg0) {
      let hide_muted_channels;
      if (null != outer1_21[arg0]) {
        hide_muted_channels = tmp.hide_muted_channels;
      }
      return true === hide_muted_channels;
    }
  };
  items[25] = {
    key: "getAllSettings",
    value() {
      return { userGuildSettings: outer1_21, mutedChannels: outer1_29, optedInChannelsByGuild: outer1_30 };
    }
  };
  items[26] = {
    key: "getChannelIdFlags",
    value(arg0, arg1) {
      const tmp = this.getChannelOverrides(arg0)[arg1];
      let flags;
      if (null != tmp) {
        flags = tmp.flags;
      }
      let num = 0;
      if (null != flags) {
        num = flags;
      }
      return num;
    }
  };
  items[27] = {
    key: "getChannelFlags",
    value(guild_id) {
      return this.getChannelIdFlags(guild_id.guild_id, guild_id.id);
    }
  };
  items[28] = {
    key: "getNewForumThreadsCreated",
    value(arg0) {
      const self = this;
      const tmp = this.getChannelOverrides(arg0.guild_id)[arg0.id];
      if (null != tmp) {
        if (null != tmp.flags) {
          if (obj.hasFlag(tmp.flags, outer1_19.NEW_FORUM_THREADS_ON)) {
            return true;
          } else {
            if (obj2.hasFlag(tmp.flags, outer1_19.NEW_FORUM_THREADS_OFF)) {
              return false;
            }
            obj2 = outer1_2(outer1_3[17]);
          }
          obj = outer1_2(outer1_3[17]);
        }
      }
      return self.resolvedMessageNotifications(arg0) === outer1_16.ALL_MESSAGES;
    }
  };
  items[29] = {
    key: "isOptInEnabled",
    value(arg0) {
      const self = this;
      if (null == arg0) {
        return tmp;
      } else if (outer1_9.isFullServerPreview(arg0)) {
        let isOptInEnabledResult = outer1_9.isOptInEnabled(arg0);
      } else {
        isOptInEnabledResult = outer1_2(outer1_3[17]).hasFlag(self.getGuildFlags(arg0), outer1_20.OPT_IN_CHANNELS_ON);
        const obj = outer1_2(outer1_3[17]);
      }
    }
  };
  items[30] = {
    key: "isChannelRecordOrParentOptedIn",
    value(guild_id) {
      const self = this;
      let tmp = null != guild_id && null != guild_id.guild_id;
      if (tmp) {
        let isChannelOptedInResult = self.isChannelOptedIn(guild_id.guild_id, guild_id.id, arg1);
        if (!isChannelOptedInResult) {
          isChannelOptedInResult = null != guild_id.parent_id && self.isChannelOptedIn(guild_id.guild_id, guild_id.parent_id, arg1);
          const tmp3 = null != guild_id.parent_id && self.isChannelOptedIn(guild_id.guild_id, guild_id.parent_id, arg1);
        }
        tmp = isChannelOptedInResult;
      }
      return tmp;
    }
  };
  items[31] = {
    key: "isChannelOrParentOptedIn",
    value(arg0, channelId) {
      return this.isChannelRecordOrParentOptedIn(outer1_13.getChannel(channelId), arg2);
    }
  };
  items[32] = {
    key: "isChannelOptedIn",
    value(arg0, arg1) {
      let flag = arg2;
      const self = this;
      if (arg2 === undefined) {
        flag = false;
      }
      if (null == arg0) {
        return false;
      } else if (outer1_9.isFullServerPreview(arg0)) {
        return outer1_9.isChannelOptedIn(arg0, arg1);
      } else {
        if (flag) {
          if (null != outer1_34[arg0]) {
            return outer1_34[arg0].has(arg1);
          }
        }
        const tmp2 = self.getChannelOverrides(arg0)[arg1];
        let flags;
        if (null != tmp2) {
          flags = tmp2.flags;
        }
        let num = 0;
        if (null != flags) {
          num = flags;
        }
        return outer1_2(outer1_3[17]).hasFlag(num, outer1_19.OPT_IN_ENABLED);
      }
    }
  };
  items[33] = {
    key: "getOptedInChannels",
    value(arg0) {
      if (outer1_9.isFullServerPreview(arg0)) {
        let viewingChannels = outer1_9.getViewingChannels(arg0);
        if (null == viewingChannels) {
          viewingChannels = outer1_32;
        }
        let tmp2 = viewingChannels;
      } else {
        tmp2 = outer1_30[arg0];
        if (null == tmp2) {
          tmp2 = outer1_32;
        }
      }
      return tmp2;
    }
  };
  items[34] = {
    key: "getOptedInChannelsWithPendingUpdates",
    value(arg0) {
      return outer1_34[arg0];
    }
  };
  items[35] = {
    key: "getPendingChannelUpdates",
    value(arg0) {
      return outer1_33[arg0];
    }
  };
  items[36] = {
    key: "getGuildFavorites",
    value(arg0) {
      const self = this;
      let closure_0 = arg0;
      if (outer1_9.isFullServerPreview(arg0)) {
        return null;
      } else {
        if (null == outer1_22[arg0]) {
          const found = outer1_1(outer1_3[16]).filter(self.getChannelOverrides(arg0), (flags) => {
            flags = flags.flags;
            let num = 0;
            if (null != flags) {
              num = flags;
            }
            let hasFlagResult = outer2_2(outer2_3[17]).hasFlag(num, outer2_19.FAVORITED);
            if (hasFlagResult) {
              const channel = outer2_13.getChannel(flags.channel_id);
              let guild_id;
              if (null != channel) {
                guild_id = channel.guild_id;
              }
              hasFlagResult = guild_id === closure_0;
            }
            return hasFlagResult;
          });
          outer1_22[arg0] = found.map((channel_id) => channel_id.channel_id);
          const arr = outer1_1(outer1_3[16]);
        }
        return outer1_22[arg0];
      }
    }
  };
  items[37] = {
    key: "isFavorite",
    value(arg0, arg1) {
      const self = this;
      let tmp = !outer1_9.isFullServerPreview(arg0);
      if (tmp) {
        const guildFavorites = self.getGuildFavorites(arg0);
        let hasItem;
        if (null != guildFavorites) {
          hasItem = guildFavorites.includes(arg1);
        }
        tmp = true === hasItem;
      }
      return tmp;
    }
  };
  items[38] = {
    key: "isMessagesFavorite",
    value(arg0) {
      const tmp = this.getChannelOverrides(null)[arg0];
      let flags;
      if (null != tmp) {
        flags = tmp.flags;
      }
      let num = 0;
      if (null != flags) {
        num = flags;
      }
      return outer1_2(outer1_3[17]).hasFlag(num, outer1_19.FAVORITED);
    }
  };
  items[39] = {
    key: "accountNotificationSettings",
    get() {
      return outer1_25;
    }
  };
  items[40] = {
    key: "useNewNotifications",
    get() {
      return outer1_23;
    }
  };
  items[41] = {
    key: "getGuildUnreadSetting",
    value(arg0) {
      const self = this;
      if (outer1_48()) {
        const guildFlags = self.getGuildFlags(arg0);
        if (obj.hasFlag(guildFlags, outer1_20.UNREADS_ALL_MESSAGES)) {
          let ALL_MESSAGES = outer1_18.ALL_MESSAGES;
        } else {
          ALL_MESSAGES = outer1_2(outer1_3[17]).hasFlag(guildFlags, outer1_20.UNREADS_ONLY_MENTIONS) ? tmp10.ONLY_MENTIONS : tmp10.UNSET;
          const obj2 = outer1_2(outer1_3[17]);
        }
        return ALL_MESSAGES;
      } else {
        return outer1_18.ALL_MESSAGES;
      }
    }
  };
  items[42] = {
    key: "resolveGuildUnreadSetting",
    value(id) {
      const guildFlags = this.getGuildFlags(id.id);
      if (outer1_48()) {
        if (obj.hasFlag(guildFlags, outer1_20.UNREADS_ALL_MESSAGES)) {
          let ONLY_MENTIONS = outer1_18.ALL_MESSAGES;
        } else {
          if (obj2.hasFlag(guildFlags, outer1_20.UNREADS_ONLY_MENTIONS)) {
            ONLY_MENTIONS = outer1_18.ONLY_MENTIONS;
          } else if (id.defaultMessageNotifications === outer1_16.ALL_MESSAGES) {
            ONLY_MENTIONS = outer1_18.ALL_MESSAGES;
          } else {
            ONLY_MENTIONS = outer1_18.ONLY_MENTIONS;
          }
          obj2 = outer1_2(outer1_3[17]);
        }
        obj = outer1_2(outer1_3[17]);
      } else {
        return outer1_18.ALL_MESSAGES;
      }
    }
  };
  items[43] = {
    key: "getChannelRecordUnreadSetting",
    value(guild_id) {
      return this.getChannelUnreadSetting(guild_id.guild_id, guild_id.id);
    }
  };
  items[44] = {
    key: "getChannelUnreadSetting",
    value(arg0, arg1) {
      const channelIdFlags = this.getChannelIdFlags(arg0, arg1);
      if (obj.hasFlag(channelIdFlags, outer1_19.UNREADS_ALL_MESSAGES)) {
        let ALL_MESSAGES = outer1_18.ALL_MESSAGES;
      } else {
        ALL_MESSAGES = outer1_2(outer1_3[17]).hasFlag(channelIdFlags, outer1_19.UNREADS_ONLY_MENTIONS) ? tmp5.ONLY_MENTIONS : tmp5.UNSET;
        const obj2 = outer1_2(outer1_3[17]);
      }
      return ALL_MESSAGES;
    }
  };
  return callback(UserGuildSettingsStoreClass, items);
})(require("initialize").PersistedStore);
tmp13.displayName = "UserGuildSettingsStore";
tmp13.persistKey = "collapsedGuilds";
tmp13 = new tmp13(require("dispatcher"), {
  USER_GUILD_SETTINGS_FULL_UPDATE: function handleUserGuildSettingsFullUpdate(userGuildSettings) {
    userGuildSettings = userGuildSettings.userGuildSettings;
    const item = userGuildSettings.forEach((guild_id) => {
      const merged = Object.assign(guild_id);
      outer1_36(guild_id.guild_id, { channel_overrides: {} });
    });
  },
  USER_GUILD_SETTINGS_GUILD_UPDATE: function handleUserGuildSettingsGuildUpdate(guildId) {
    updateUserGuildSettings(guildId.guildId, guildId.settings);
  },
  USER_GUILD_SETTINGS_GUILD_AND_CHANNELS_UPDATE: function handleUserGuildSettingsGuildAndChannelsUpdate(arg0) {
    let guildId;
    let settings;
    ({ guildId, settings } = arg0);
    updateUserGuildSettings(guildId, settings);
    updateUserGuildChannelSettingsBulk(guildId, settings.channel_overrides);
  },
  USER_GUILD_SETTINGS_CHANNEL_UPDATE: function handleUserGuildSettingsChannelUpdate(arg0) {
    let channelId;
    let guildId;
    let settings;
    ({ guildId, channelId, settings } = arg0);
    if (tmp) {
      let obj = {};
      const merged = Object.assign(dependencyMap2[guildId]);
      obj = { flags: settings.flags };
      obj[channelId] = obj;
      dependencyMap2[guildId] = obj;
    }
    updateUserGuildChannelSettings(guildId, channelId, settings);
  },
  USER_GUILD_SETTINGS_CHANNEL_UPDATE_BULK: function handleUserGuildSettingsChannelUpdateBulk(guildId) {
    guildId = guildId.guildId;
    let flag = null != guildId;
    if (flag) {
      flag = !fullServerPreview.isFullServerPreview(guildId);
    }
    if (flag) {
      updateUserGuildChannelSettingsBulk(guildId, guildId.overrides);
      flag = true;
    }
    return flag;
  },
  CONNECTION_OPEN: function handleConnectionOpen(notificationSettings) {
    processAccountNotificationSettings(notificationSettings.notificationSettings);
    importDefaultResult.reset();
    importDefaultResult1.reset();
    if (!notificationSettings.userGuildSettings.partial) {
      const dependencyMap = {};
      let closure_29 = {};
      let closure_30 = {};
    }
    const set = new Set();
    const entries = notificationSettings.userGuildSettings.entries;
    const item = entries.forEach((guild_id) => {
      if (!("channel_overrides" in guild_id)) {
        guild_id.channel_overrides = {};
      }
      outer1_36(guild_id.guild_id, guild_id);
      if (null != guild_id.guild_id) {
        set.add(guild_id.guild_id);
      }
    });
    for (const key10030 in closure_21) {
      let tmp8 = key10030;
      if (set.has(key10030)) {
        continue;
      } else {
        let tmp5 = setMuteTimers;
        let tmp6 = dependencyMap;
        let tmp7 = setMuteTimers(key10030, dependencyMap[key10030]);
        continue;
      }
      continue;
    }
  },
  CACHE_LOADED: function handleCacheLoaded(userGuildSettings) {
    let tmp = null != userGuildSettings.userGuildSettings;
    if (tmp) {
      tmp = 0 !== userGuildSettings.userGuildSettings.length;
    }
    if (tmp) {
      let closure_21 = {};
      let closure_29 = {};
      let closure_30 = {};
      userGuildSettings = userGuildSettings.userGuildSettings;
      const item = userGuildSettings.forEach((guild_id) => {
        guild_id = guild_id.guild_id;
        closure_21[guild_id] = guild_id;
        const set = new Set();
        const set1 = new Set();
        for (const key10022 in arg0.channel_overrides) {
          let tmp6 = key10022;
          let tmp7 = arg0.channel_overrides[key10022];
          let tmp8 = outer1_0;
          let tmp9 = outer1_3;
          let obj4 = outer1_0(outer1_3[15]);
          if (obj4.computeIsMuted(tmp7)) {
            let addResult = set.add(key10022);
          }
          let tmp2 = outer1_2;
          let tmp3 = outer1_3;
          let obj3 = outer1_2(outer1_3[17]);
          let flags = tmp7.flags;
          let num = 0;
          if (null != flags) {
            num = flags;
          }
          let tmp4 = outer1_19;
          if (!obj3.hasFlag(num, outer1_19.OPT_IN_ENABLED)) {
            continue;
          } else {
            let addResult1 = set1.add(key10022);
            continue;
          }
          continue;
        }
        closure_29[guild_id] = set;
        closure_30[guild_id] = set1;
      });
    }
  },
  OVERLAY_INITIALIZE: function handleOverlayInitialize(allUserGuildSettings) {
    allUserGuildSettings = allUserGuildSettings.allUserGuildSettings;
    const mutedChannels = allUserGuildSettings.mutedChannels;
    const optedInChannelsByGuild = allUserGuildSettings.optedInChannelsByGuild;
    const obj = {};
    const merged = Object.assign(allUserGuildSettings.userGuildSettings);
    let closure_29 = {};
    let closure_30 = {};
    const keys = optedInChannelsByGuild(21).keys(mutedChannels);
    const item = keys.forEach((arg0) => {
      closure_29[arg0] = new Set(mutedChannels[arg0]);
    });
    const obj2 = optedInChannelsByGuild(21);
    const keys1 = optedInChannelsByGuild(21).keys(optedInChannelsByGuild);
    const item1 = keys1.forEach((arg0) => {
      closure_30[arg0] = new Set(optedInChannelsByGuild[arg0]);
    });
  },
  GUILD_CREATE: handleGuildUpdate,
  GUILD_UPDATE: handleGuildUpdate,
  GUILD_TOGGLE_COLLAPSE_MUTED: function handleToggleCollapseMuted(guildId) {
    guildId = guildId.guildId;
    if (null == dependencyMap[guildId]) {
      let tmp2 = getGuildDefaults(guildId);
    } else {
      tmp2 = dependencyMap[guildId];
    }
    const obj = {};
    const merged = Object.assign(tmp2);
    obj["guild_id"] = guildId;
    obj["hide_muted_channels"] = true !== tmp2.hide_muted_channels;
    dependencyMap[guildId] = obj;
  },
  IMPERSONATE_UPDATE: handleGuildUpdate,
  IMPERSONATE_STOP: handleGuildUpdate,
  USER_GUILD_SETTINGS_REMOVE_PENDING_CHANNEL_UPDATES: function handleRemovePendingUpdates(arg0) {
    let guildId;
    let updates;
    ({ guildId, updates } = arg0);
    if (null == guildId) {
      return false;
    } else if (null == dependencyMap2[guildId]) {
      return false;
    } else {
      for (const key10010 in updates) {
        let tmp6 = key10010;
        let tmp7 = importDefault;
        let tmp8 = dependencyMap;
        let obj = importDefault(22);
        if (!obj.isEqual(updates[key10010], tmp4[key10010])) {
          continue;
        } else {
          delete tmp[tmp2];
          continue;
        }
        continue;
      }
    }
  },
  CLEAR_PENDING_CHANNEL_AND_ROLE_UPDATES: function handleClearPendingUpdates(guildId) {
    if (null == guildId.guildId) {
      return false;
    } else {
      delete tmp3[tmp2];
      delete tmp[tmp2];
    }
  },
  NOTIFICATION_SETTINGS_UPDATE: function handleNotificationSettingsUpdate(settings) {
    processAccountNotificationSettings(settings.settings);
  },
  GUILD_MUTE_EXPIRED() {
    return true;
  },
  CHANNEL_MUTE_EXPIRED() {
    return true;
  }
});
let result = set.fileFinishedImporting("stores/UserGuildSettingsStore.tsx");

export default tmp13;
export { getGuildDefaults };
export { convertChannelOverridesToMap };