// Module ID: 6900
// Function ID: 6901
// Name: CacheStore
// Dependencies: [32, 5, 5590, 502, 2102, 4657, 1086, 3, 510, 2099, 6901, 6912, 9, 10, 2098, 6913, 6914, 6915, 6916, 6917, 7061, 7082, 504, 585, 2097, 7067, 7073, 7071, 7065, 559, 7083, 1370, 7085, 7087, 2094, 2]

// Module 6900 (CacheStore)
import LoggerDefault from "Logger" /* 3 */;
import AppStartPerformanceDefault from "AppStartPerformance" /* 10 */;
import get_initializedDefault from "get initialized" /* 504 */;
import Storage4 from "Storage" /* 510 */;
import DispatcherDefault from "Dispatcher" /* 585 */;
import TryLoad from "TryLoad" /* 2097 */;
import modules_MessagesDefault from "modules/Messages" /* 6901 */;
import timeRequireDefault from "timeRequire" /* 6916 */;
import NonGuildVersionsDefault from "NonGuildVersions" /* 7073 */;
import AuthenticationUtils from "AuthenticationUtils" /* 7085 */;
import _slicedToArray from "_slicedToArray" /* 32 */;
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
import GatewayConnectionStore from "GatewayConnectionStore" /* 5590 */;
import AuthenticationStore from "AuthenticationStore" /* 502 */;
import SelectedChannelStore from "SelectedChannelStore" /* 2102 */;
import SelectedGuildStore from "SelectedGuildStore" /* 4657 */;
import Constants from "Constants" /* 1086 */;
import size from "module_2" /* 2 */;

let c4, closure_13, dependencyMap, importDefault, length2, length3, set;

let c10;
let c9;
let closure_12;
let tmp;
let unpackModuleId;
const TTITrackerDefault = tmp(9);
function handleClearCaches(type) {
  closure_13.log("Clearing cache store");
  closure_16 = Date.now();
  const Storage = Storage4.Storage;
  Storage.remove(authStore);
  const Storage2 = Storage4.Storage;
  Storage2.remove(unpackModuleId);
  const Storage3 = Storage4.Storage;
  Storage3.remove(closure_12);
  initializing = "no-cache";
  const tmp5 = "CLEAR_CACHES" === type.type && type.preventWritingCachesAgainThisSession;
  if (tmp5) {
    c14 = true;
  }
}
let obj = function _loadChannelHistory() {
  obj = _asyncToGenerator(async (guildId, channelId, arg2) => {
    let closure_3;
    let closure_2 = arg2;
    let c5 = 0;
    let c6 = 0;
    return (async (arg0, value, arg2) => {
      if (c6 === 2) {
        c6 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          let tmp;
          let obj9;
          let c2;
          c6 = 2;
          if (0 === c5) {
            if (arg0 === 1) {
              c6 = 3;
              throw value;
            } else if (arg0 === 2) {
              c6 = 3;
              return { value, done: true };
            } else {
              closure_4 = tmp4;
              guildId = channelId;
              channelId = closure_2;
              tmp = undefined;
              obj9 = undefined;
              const _performance3 = performance;
              const nowResult = performance.now();
              c2 = nowResult;
              if (null != guildId) {
                if (null != closure_2) {
                  c5 = 1;
                  c6 = 1;
                  const obj5 = modules_MessagesDefault;
                  const obj4 = { value: obj5.startupLoad(guildId, channelId, closure_2, closure_2_9), done: false };
                  return obj4;
                }
              }
              const _HermesInternal = HermesInternal;
              closure_2_13.verbose("skipped loaded messages (channel: " + closure_2 + ", database: " + guildId + ").");
              const _performance = performance;
              const items = [performance.now() - nowResult, ];
              const obj6 = { guildId: null, channelId: null, users: [], members: [], messages: [] };
              items[1] = obj6;
              c6 = 3;
              return { value: items, done: true };
            }
          } else if (arg0 === 1) {
            c6 = 3;
            throw value;
          } else if (arg0 === 2) {
            c6 = 3;
            return { value, done: true };
          } else {
            tmp = value;
            const _HermesInternal2 = HermesInternal;
            closure_132_13.verbose("loaded " + tmp.messages.length + " messages (guild: " + guildId + ", channel: " + channelId + ").");
            obj9 = { guildId, channelId, users: tmp.users, members: tmp.members, messages: tmp.messages };
            const obj10 = closure_132_1(closure_132_2[11]);
            const result = obj10.recordChannelFetchedLocal(channelId, closure_132_0(closure_132_2[11]).INITIAL_MESSAGE_FETCH_KEY, null, null, closure_132_9, tmp.messages);
            const _performance2 = performance;
            const items1 = [performance.now() - c2, obj9];
            c6 = 3;
            return { value: items1, done: true };
          }
        } catch (tmp16) {
          c6 = 3;
          throw tmp16;
        }
      }
    })();
  });
  return obj(...arguments);
};
obj = function _loadEarlyCache() {
  obj = _asyncToGenerator(async (arg0, arg1, arg2) => {
    let name = arg0;
    let closure_1 = arg1;
    let closure_2 = arg2;
    let c8 = 0;
    let c9 = 0;
    return (async function(arg0, value, arg2) {
      let length1;
      let resolved;
      let resolved1;
      let resolved2;
      let timeAsyncResult;
      closure_7 = tmp;
      closure_6 = tmp2;
      closure_2_13.verbose("loading early cache");
      socket = socket.getSocket();
      socket.connect();
      const guildId1 = guildId.getGuildId();
      c3 = guildId1;
      if (guildId1 == null) {
        c3 = null;
      }
      let closure_4 = c3;
      const channelId1 = channelId.getChannelId();
      c4 = channelId1;
      if (channelId1 == null) {
        c4 = null;
      }
      let closure_5 = c4;
      const _performance = performance;
      closure_6 = performance.now();
      const loadCachedMessages = TTITrackerDefault.loadCachedMessages;
      const result = loadCachedMessages.measureAsyncWithoutNesting(async () => {
        function loadChannelHistory() {
          return closure_1_20(...arguments);
        }
        return loadChannelHistory(closure_1_0, closure_1_4, closure_1_5);
      });
      const fetchGuildCache = TTITrackerDefault.fetchGuildCache;
      const measureAsyncResult = fetchGuildCache.measureAsync(async () => {
        function loadInitialGuilds() {
          return closure_1_23(...arguments);
        }
        return loadInitialGuilds(closure_1_0, closure_1_2);
      });
      const fetchGuildCache2 = TTITrackerDefault.fetchGuildCache;
      const measureAsyncResult1 = fetchGuildCache2.measureAsync(async () => {
        function loadInitialGuildChannels() {
          return closure_1_24(...arguments);
        }
        return loadInitialGuildChannels(closure_1_0, closure_1_2);
      });
      if (null != name) {
        const obj8 = AppStartPerformanceDefault;
        timeAsyncResult = obj8.timeAsync("\u{1F4BE}", "cache: private_channels", async () => {
          obj = closure_2_1(closure_2_2[14]);
          return obj.getAsync(closure_1_0, null);
        });
      } else {
        timeAsyncResult = Promise.resolve([]);
      }
      if (null == name) {
        resolved = Promise.resolve({});
      } else {
        const obj9 = AppStartPerformanceDefault;
        resolved = obj9.timeAsync("\u{1F4BE}", "cache: user_settings", async () => {
          obj = closure_2_1(closure_2_2[15]);
          return obj.getAll(closure_1_0);
        });
      }
      if (null == name) {
        resolved1 = Promise.resolve([]);
      } else {
        const obj10 = AppStartPerformanceDefault;
        resolved1 = obj10.timeAsync("\u{1F4BE}", "cache: read_states", async () => {
          obj = closure_2_1(closure_2_2[16]);
          return obj.getAll(closure_1_0);
        });
      }
      if (null == name) {
        resolved2 = Promise.resolve([]);
      } else {
        const obj11 = AppStartPerformanceDefault;
        resolved2 = obj11.timeAsync("\u{1F4BE}", "cache: user_guild_settings", async () => {
          obj = closure_2_1(closure_2_2[17]);
          return obj.getAll(closure_1_0);
        });
      }
      timeRequireDefault("AllCacheStores", () => name(closure_1_2[19]));
      timeRequireDefault("MobileAppDatabaseManager", () => name(closure_1_2[20]));
      let items = [result, measureAsyncResult, measureAsyncResult1, timeAsyncResult, resolved, resolved1, resolved2];
      closure_7 = await Promise.all(items);
      let closure_8 = closure_135_3(closure_7, 7);
      let closure_9 = closure_135_3(closure_8[0], 2);
      let closure_10 = closure_9[0];
      let closure_11 = closure_9[1];
      length = closure_8[1];
      closure_13 = closure_8[2];
      let closure_14 = closure_8[3];
      let closure_15 = closure_8[4];
      length2 = closure_8[5];
      length3 = closure_8[6];
      const _performance2 = performance;
      let closure_18 = performance.now() - closure_6;
      const _HermesInternal2 = HermesInternal;
      closure_135_13.verbose("cache loaded in " + closure_18 + "ms (channel_history " + closure_10 + "ms)");
      if (null == closure_11) {
        closure_135_1(closure_135_2[21])("database:history_cache_null");
        closure_135_13.verbose("finished without dispatching CACHE_LOADED");
        const items1 = [false, null, 0];
        return items1;
      }
      const _Object2 = Object;
      const members = closure_11.members;
      let closure_19 = Object.fromEntries(members.map((userId) => {
        const items = [userId.userId, userId];
        return items;
      }));
      let closure_20 = null != closure_13.guildId && null != closure_13.channels;
      guildId = closure_13.guildId;
      const self = this;
      const self2 = this;
      const tmp51 = null != closure_13.guildId && null != closure_13.channels;
      const promise = new Promise((arg0, arg1) => {
        let guilds;
        let privateChannels;
        let readStates;
        let userGuildSettings;
        let userSettings;
        let closure_0 = arg0;
        closure_1 = arg1;
        const Emitter = closure_1_1(closure_1_2[22]).Emitter;
        return Emitter.batched(() => {
          obj = closure_1(closure_2[13]);
          obj.time("\u{1F4BE}", "Dispatch Mini Cache", () => {
            let items;
            let obj2;
            let obj3;
            obj = { type: "CACHE_LOADED", guilds, privateChannels, initialGuildChannels: channels, users: items, messages: obj2, guildMembers: obj3, userSettings, userGuildSettings, readStates };
            channels = channels.channels;
            const dispatch = closure_3_1(closure_3_2[23]).dispatch;
            closure_3_1(closure_3_2[23]);
            if (channels == null) {
              channels = [];
            }
            items = [...closure_2_11.users];
            if (null == closure_2_11.channelId) {
              obj2 = {};
            } else {
              obj2 = {};
              obj2[closure_2_11.channelId] = closure_2_11.messages;
            }
            if (null == closure_2_11.guildId) {
              obj3 = {};
            } else {
              obj3 = {};
              obj3[closure_2_11.guildId] = closure_2_19;
            }
            const dispatchResult = dispatch(obj);
            return dispatchResult.then(closure_1_0, closure_1_1);
          });
          let obj2 = closure_1(closure_2[13]);
          obj2.time("\u{1F4BE}", "socket.processFirstQueuedDispatch()", () => {
            dispatcher = dispatcher.dispatcher;
            const processFirstQueuedDispatch = dispatcher.processFirstQueuedDispatch;
            set = new Set(["INITIAL_GUILD"]);
            return processFirstQueuedDispatch(set);
          });
        });
      });
      await promise;
      const _JSON = JSON;
      const verbose = closure_135_13.verbose;
      const json = JSON.stringify(closure_2);
      if (name != null) {
        name = name.name;
      }
      length = closure_14.length;
      guildId = closure_11.guildId;
      channelId = closure_11.channelId;
      length2 = closure_11.messages.length;
      length3 = closure_11.members.length;
      let channels = closure_13.channels;
      if (channels != null) {
        length1 = channels.length;
      }
      const _Object = Object;
      const _HermesInternal = HermesInternal;
      verbose("early_cache_summary: (\n        ok: true\n        meta:\n          auth_user_id: " + closure_1 + "\n          selected_guild: " + closure_4 + "\n          selected_channel: " + closure_5 + "\n          navigation_state: " + json + "\n          database: " + null != name + "\n            name: " + name + "\n        data:\n          database:\n            private_channels: " + length + "\n            channel_history:\n              guild: " + guildId + "\n              channel: " + channelId + "\n              messages: " + length2 + "\n                members: " + length3 + "\n                users: " + closure_11.users.length + "\n            initial_guild:\n              id: " + guildId + "\n              channels: " + length1 + "\n            user_settings: " + Object.keys(closure_15).length + "\n            read_states: " + length2.length + "\n            user_guild_settings: " + length3.length + "\n      )");
      obj = closure_135_1(closure_135_2[12]);
      const obj13 = { guilds: length.length };
      obj.setEarlyCacheInfo(obj13);
      closure_135_13.verbose("finished dispatching CACHE_LOADED");
      const items2 = [true, , ];
      let tmp44 = null;
      if (closure_20) {
        c5 = guildId;
        if (guildId == null) {
          c5 = null;
        }
        tmp44 = c5;
      }
      items2[1] = tmp44;
      items2[2] = closure_14.length;
      return items2;
    })();
  });
  return obj(...arguments);
};
obj = function _loadInitialGuilds() {
  obj = _asyncToGenerator(async (arg0, arg1) => {
    let closure_0 = arg0;
    let guildId = arg1;
    let c6 = 0;
    let c7 = 0;
    return (async (arg0, value) => {
      let obj11;
      let obj3;
      let obj9;
      if (c7 === 2) {
        c7 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          let closure_3;
          c7 = 2;
          if (0 === c6) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              return { value, done: true };
            } else {
              closure_5 = tmp;
              closure_4 = tmp4;
              value = undefined;
              closure_3 = undefined;
              if (null == closure_0) {
                c7 = 3;
                return { value: [], done: true };
              } else {
                const page = tmp32.page;
                if ("private-channels" !== page) {
                  if ("guild-channels" !== page) {
                    if ("other" === page) {
                      if ("@me" === guildId.guildId) {
                        c22 = true;
                      }
                    }
                  }
                  const tmp21 = c22;
                  if (tmp21) {
                    c6 = 1;
                    c7 = 1;
                    const obj6 = {
                      value: obj11.tryLoadAsync(async () => {
                                      obj = guildId(closure_2_2[13]);
                                      return obj.timeAsync("\u{1F4BE}", "cache: guilds", async () => {
                                        obj = closure_2_1(closure_2_2[25]);
                                        return obj.getAsync(closure_1_0);
                                      });
                                    }),
                      done: false
                    };
                    obj11 = TryLoad;
                    return obj6;
                  } else {
                    c6 = 2;
                    c7 = 1;
                    const obj7 = { value: obj9.getCommittedVersions(), done: false };
                    obj9 = NonGuildVersionsDefault;
                    return obj7;
                  }
                }
                c22 = true;
              }
            }
          } else if (1 === c6) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              return { value, done: true };
            } else {
              if (value == null) {
                value = [];
              }
              c7 = 3;
              return { value, done: true };
            }
          } else if (2 === c6) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              return { value, done: true };
            } else {
              const initial_guild_id = value.initial_guild_id;
              guildId = initial_guild_id;
              if (initial_guild_id == null) {
                guildId = guildId.guildId;
              }
              value = guildId;
              if (null != value) {
                if ("@me" !== value) {
                  c6 = 3;
                  c7 = 1;
                  const obj13 = {
                    value: obj3.tryLoadAsync(async () => {
                                  obj = guildId(closure_2[25]);
                                  return obj.getOneAsync(closure_1_0, closure_1_2);
                                }),
                    done: false
                  };
                  obj3 = closure_133_0(closure_133_2[24]);
                  return obj13;
                }
              }
              c7 = 3;
              return { value: [], done: true };
            }
          } else if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            return { value, done: true };
          } else {
            let items1;
            closure_3 = value;
            if (null != closure_3) {
              const items = [closure_3];
              items1 = items;
            } else {
              items1 = [];
            }
            c7 = 3;
            obj = { value: items1, done: true };
            return obj;
          }
        } catch (tmp26) {
          c7 = 3;
          throw tmp26;
        }
      }
    })();
  });
  return obj(...arguments);
};
obj = function _loadInitialGuildChannels() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let obj3;
    let obj7;
    let closure_0 = arg0;
    let closure_1 = value;
    if (c6 === 2) {
      c6 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let guildId;
        c6 = 2;
        if (0 === c5) {
          if (arg0 === 1) {
            c6 = 3;
            throw value;
          } else if (arg0 === 2) {
            c6 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            let closure_4 = tmp4;
            guildId = undefined;
            let closure_3;
            if (null == closure_0) {
              c6 = 3;
              const obj5 = { value: Promise.resolve({ channels: null, guildId: null }), done: true };
              return obj5;
            } else {
              c5 = 1;
              c6 = 1;
              const obj6 = { value: obj7.getCommittedVersions(), done: false };
              obj7 = NonGuildVersionsDefault;
              return obj6;
            }
          }
        } else if (1 === c5) {
          if (arg0 === 1) {
            c6 = 3;
            throw value;
          } else if (arg0 === 2) {
            c6 = 3;
            const obj8 = { value, done: true };
            return obj8;
          } else {
            guildId = value.initial_guild_id;
            const tmp11 = null == guildId && "guild-channels" === closure_1.page;
            if (tmp11) {
              guildId = closure_1.guildId;
            }
            if (null != closure_0) {
              if (null != guildId) {
                closure_3 = guildId;
                value = {};
                c5 = 2;
                c6 = 1;
                const obj9 = {
                  value: obj3.tryLoadAsync(async () => {
                                obj = closure_1(closure_2[14]);
                                return obj.getAsync(closure_1_0, closure_1_3);
                              }),
                  done: false
                };
                obj3 = closure_132_0(closure_132_2[24]);
                return obj9;
              }
            }
            const _HermesInternal = HermesInternal;
            closure_132_13.verbose("skipped loading initial guild (guild: " + guildId + ", database: " + closure_0 + ")");
            c6 = 3;
            const obj10 = { value: Promise.resolve({ channels: null, guildId: null }), done: true };
            return obj10;
          }
        } else if (arg0 === 1) {
          c6 = 3;
          throw value;
        } else if (arg0 === 2) {
          c6 = 3;
          const obj11 = { value, done: true };
          return obj11;
        } else {
          value.channels = value;
          value.guildId = guildId;
          c6 = 3;
          obj = { value, done: true };
          return obj;
        }
      } catch (tmp33) {
        c6 = 3;
        throw tmp33;
      }
    }
  });
  return obj(...arguments);
};
obj = function _loadLateLazyCache() {
  obj = _asyncToGenerator(async (arg0, value, arg2, arg3) => {
    let closure_2;
    let closure_3;
    let tmp3;
    let closure_0 = arg0;
    let closure_1 = value;
    if (c7 === 2) {
      c7 = 3;
      let str3 = "Generator functions may not be called on executing generators";
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        let obj3 = { value, done: true };
        return obj3;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let closure_4;
        let closure_5;
        c7 = 2;
        const tmp4 = c6;
        if (0 === c6) {
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            let obj4 = { value, done: true };
            return obj4;
          } else {
            closure_4 = undefined;
            closure_5 = undefined;
            let closure_6;
            let guilds;
            let closure_8;
            let guildChannels;
            let socket;
            const str4 = "loading late lazy cache";
            const verboseResult = closure_2_13.verbose("loading late lazy cache");
            const fetchLazyCache = TTITrackerDefault.fetchLazyCache;
            c6 = 1;
            c7 = 1;
            let obj5 = {
              value: fetchLazyCache.measureAsync(async () => {
                        obj = closure_2_0(initialGuildId[24]);
                        const items = [
                          obj.tryLoadAsync(async () => {
                            let timeAsyncResult;
                            if (null != closure_1_0) {
                              obj = closure_2_1(initialGuildId[13]);
                              timeAsyncResult = obj.timeAsync("\u{1F4BE}", "cache: cache_version", async () => {
                                obj = closure_2_1(closure_2_2[27]);
                                return obj.okAsync(closure_1_0);
                              });
                            } else {
                              timeAsyncResult = Promise.resolve(true);
                            }
                            return timeAsyncResult;
                          }),
                        ,

                        ];
                        let obj2 = closure_2_0(initialGuildId[24]);
                        items[1] = obj2.tryLoadAsync(async () => {
                          if (null != closure_1_0) {
                            let timeAsyncResult;
                            const tmp = closure_2_22;
                            if (!tmp) {
                              obj = closure_2_1(initialGuildId[13]);
                              timeAsyncResult = obj.timeAsync("\u{1F4BE}", "cache: lazy guilds", async () => {
                                obj = closure_2_1(closure_2_2[25]);
                                return obj.getAsync(closure_1_0);
                              });
                            }
                            return timeAsyncResult;
                          }
                          timeAsyncResult = Promise.resolve([]);
                        });
                        const obj3 = closure_2_0(initialGuildId[24]);
                        items[2] = obj3.tryLoadAsync(async () => {
                          let timeAsyncResult;
                          if (null != closure_1_0) {
                            const obj2 = closure_2_1(initialGuildId[13]);
                            timeAsyncResult = obj2.timeAsync("\u{1F4BE}", "cache: basic_channels", async () => {
                              obj = closure_2_1(closure_2_2[28]);
                              return obj.getAsync(closure_1_0);
                            });
                          } else {
                            obj = { all: [], stale: [], channels: [] };
                            timeAsyncResult = Promise.resolve(obj);
                          }
                          return timeAsyncResult;
                        });
                        return all(items);
                      }),
              done: false
            };
            return obj5;
          }
        } else if (1 === tmp4) {
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            let obj6 = { value, done: true };
            return obj6;
          } else {
            closure_4 = value;
            closure_5 = closure_133_3(closure_4, 3);
            closure_6 = closure_5[0];
            guilds = closure_5[1];
            closure_8 = closure_5[2];
            const fetchStaleChannels = closure_133_1(closure_133_2[12]).fetchStaleChannels;
            c6 = 2;
            c7 = 1;
            let obj7 = {
              value: fetchStaleChannels.measureAsync(async () => {
                        if (null != closure_1_0) {
                          if (null != closure_1_8) {
                            let tryLoadAsyncResult;
                            if (closure_1_8.stale.length > 0) {
                              obj = closure_0(initialGuildId[24]);
                              tryLoadAsyncResult = obj.tryLoadAsync(async () => {
                                stale = stale.stale;
                                closure_0 = closure_1_0;
                                closure_2_13.verbose("loading stale guild channels (count: " + stale.length + ", ids: " + stale.join(", ") + ")");
                                return Promise.all(stale.map((item) => {
                                  closure_0 = item;
                                  obj = closure_2_1(closure_2_2[14]);
                                  const async = obj.getAsync(closure_0, item);
                                  return async.then((result) => {
                                    const items = [closure_0, result];
                                    return items;
                                  });
                                }));
                              });
                            }
                            return tryLoadAsyncResult;
                          }
                        }
                        tryLoadAsyncResult = Promise.resolve([]);
                      }),
              done: false
            };
            return obj7;
          }
        } else {
          if (2 === tmp4) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              let obj8 = { value, done: true };
              return obj8;
            } else {
              guildChannels = value;
              const DelayLoadLateLazyCacheHoldoutExperiment = closure_133_0(closure_133_2[29]).DelayLoadLateLazyCacheHoldoutExperiment;
              let verbose = closure_133_13.verbose;
              if (DelayLoadLateLazyCacheHoldoutExperiment.getCachedEnabled()) {
                const str2 = "loadLateLazyCache: not yielding to react";
                const verboseResult1 = verbose("loadLateLazyCache: not yielding to react");
              } else {
                const str = "loadLateLazyCache: yielding to react";
                verbose("loadLateLazyCache: yielding to react");
                const tmp8 = closure_133_0(closure_133_2[30]);
                let tmp9 = closure_133_0;
                let tmp10 = closure_133_2;
                const waitSafelyForPostTTI = tmp8.waitSafelyForPostTTI;
                let obj2 = closure_133_0(closure_133_2[31]);
                let num4;
                if (obj2.isIOS()) {
                  num4 = 0;
                }
                c6 = 3;
                c7 = 1;
                let obj9 = { value: waitSafelyForPostTTI(num4), done: false };
                return obj9;
              }
            }
          } else if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            obj = { value, done: true };
            return obj;
          }
          let tmp14 = closure_133_1;
          const loadLazyCache = closure_133_1(closure_133_2[12]).loadLazyCache;
          loadLazyCache.recordStart();
          socket = closure_133_5.getSocket();
          closure_133_26(() => {
            if (false === closure_1_6) {
              closure_1(initialGuildId[21])("database:not_ok");
              const obj9 = closure_1(initialGuildId[23]);
              obj9.dispatch({ type: "CLEAR_CACHES", reason: "database:not_ok" });
              const obj10 = closure_1(initialGuildId[23]);
              obj10.dispatch({ type: "CACHE_LOADED_LAZY_NO_CACHE" });
            } else {
              if (null != guilds) {
                if (null != closure_1_8) {
                  if (null != guildChannels) {
                    if (null == closure_1_6) {
                      closure_1(initialGuildId[21])("database:versionless");
                      closure_2_13.log("kv_cache was not ok (null version with values)");
                      const obj5 = closure_1(initialGuildId[23]);
                      obj5.dispatch({ type: "CLEAR_CACHES", reason: "database:versionless" });
                      const obj6 = closure_1(initialGuildId[23]);
                      obj6.dispatch({ type: "CACHE_LOADED_LAZY_NO_CACHE" });
                    }
                    const tmp3 = closure_2_18;
                    if (tmp3) {
                      closure_1(initialGuildId[21])("already_connected");
                      closure_2_13.log("Skipping lazy cache; already connected.");
                      const obj4 = closure_1(initialGuildId[23]);
                      obj4.dispatch({ type: "CACHE_LOADED_LAZY_NO_CACHE" });
                    } else {
                      closure_1_10.addAnalytics({ hadCacheAtStartup: true });
                      obj = { type: "CACHE_LOADED_LAZY", guilds, guildChannels, basicGuildChannels: closure_1_8.channels, initialGuildId };
                      const deserializeCache = closure_1(initialGuildId[12]).deserializeCache;
                      deserializeCache.measure(() => {
                        if (null != obj.channels) {
                          closure_2_1(initialGuildId[9])(obj.channels);
                        }
                        if (null != obj.privateChannels) {
                          closure_2_1(initialGuildId[9])(obj.privateChannels);
                        }
                        if (null != obj.guildChannels) {
                          obj = closure_2_0(initialGuildId[9]);
                          const result = obj.deserializeChannelEntries(tmp.guildChannels);
                        }
                      });
                      const dispatchLazyCache = closure_1(initialGuildId[12]).dispatchLazyCache;
                      dispatchLazyCache.measure(() => {
                        obj = closure_2_1(initialGuildId[23]);
                        return obj.dispatch(obj);
                      });
                      const _performance = performance;
                      const _HermesInternal = HermesInternal;
                      closure_2_13.verbose("late lazy cache loaded (ok: true, took: " + performance.now() - tmp + "ms)");
                      closure_1_10.addAnalytics({ usedCacheAtStartup: true });
                      const reduced = guildChannels.reduce((acc, item) => {
                        let arr;
                        [, arr] = item;
                        return acc + arr.length;
                      }, 0);
                      const all = closure_1_8.all;
                      const length = guildChannels.length;
                      const reduced1 = all.reduce((acc, item) => {
                        let arr;
                        [, arr] = item;
                        return acc + arr.length;
                      }, 0);
                      const channels = closure_1_8.channels;
                      const reduced2 = channels.reduce((acc, item) => {
                        let arr;
                        [, arr] = item;
                        return acc + arr.length;
                      }, 0);
                      const diff = reduced1 - reduced2;
                      let str3 = "";
                      const tmp10 = closure_1;
                      const tmp11 = initialGuildId;
                      const tmp14 = closure_2_13;
                      const tmp9 = initialGuildId;
                      if (0 !== closure_1_8.stale.length) {
                        const stale = closure_1_8.stale;
                        const _HermesInternal2 = HermesInternal;
                        str3 = " \u00B7 " + stale.join(", ");
                      }
                      let name;
                      const verbose = tmp14.verbose;
                      if (closure_1_0 != null) {
                        name = closure_1_0.name;
                      }
                      const _HermesInternal3 = HermesInternal;
                      verbose("lazy_cache_summary: (\n        ok: true\n        meta:\n          auth_user_id: " + closure_1_1 + "\n          initial_guild: " + tmp9 + "\n          database: " + null != closure_1_0 + "\n            ok: " + closure_1_6 + "\n            name: " + name + "\n        data:\n          database:\n            guilds: " + guilds.length + "\n            basic_channels:\n              total: " + reduced1 + " (" + closure_1_8.channels.length + " guilds)\n              stale: " + diff + " (" + closure_1_8.stale.length + " guilds" + str3 + ")\n              unstale: " + reduced2 + "\n            full_channels (guilds_with_stale_basic_channels):\n              total: " + reduced + " (" + guildChannels.length + " guilds)\n      )");
                      const obj2 = { guilds: guilds.length, privateChannels, basicChannels: reduced1, basicChannelsStale: diff, fullChannels: reduced, fullChannelGuilds: length };
                      const tmp10Result = tmp10(tmp11[12]);
                      tmp10Result.setLazyCacheInfo(obj2);
                    }
                  }
                }
              }
              closure_1(initialGuildId[21])("database:load_failed");
              const _HermesInternal4 = HermesInternal;
              closure_2_13.log("couldn't load database item (\n          database: " + null != closure_1_0 + "\n          basic_channels: " + null != closure_1_8 + "\n          guild_channels: " + null != guildChannels + "\n          guilds: " + null != guilds + "\n        )");
              const obj7 = closure_1(initialGuildId[23]);
              obj7.dispatch({ type: "CLEAR_CACHES", reason: "database:load_failed" });
              const obj8 = closure_1(initialGuildId[23]);
              obj8.dispatch({ type: "CACHE_LOADED_LAZY_NO_CACHE" });
            }
          });
          c7 = 3;
          return { value: "IconComponent", done: null };
        }
      } catch (tmp20) {
        c7 = 3;
        throw tmp20;
      }
    }
  });
  return obj(...arguments);
};
function resumeFluxAndSocket(arg0) {
  let c2;
  let closure_1;
  let closure_0 = arg0;
  importDefault = GatewayConnectionStore.getSocket();
  dependencyMap = false;
  const Emitter = get_initializedDefault.Emitter;
  Emitter.batched(function() {
    let dispatcher;
    let obj3;
    try {
      f152655();
      dispatcher = dispatcher.dispatcher;
      if (dispatcher.hasStuffToDispatchNow()) {
        let c2 = true;
        const loadLazyCache = closure_2_1(closure_2_2[12]).loadLazyCache;
        loadLazyCache.recordEnd();
        logger.verbose("Processing First Queued Dispatch");
        const dispatcher3 = tmp3.dispatcher;
        const _Set = Set;
        const self = this;
        const self2 = this;
        const processFirstQueuedDispatch = dispatcher3.processFirstQueuedDispatch;
        set = new Set(["READY", "INITIAL_GUILD"]);
        const result = processFirstQueuedDispatch(set);
        _setTimeout = setTimeout;
        const timerId = setTimeout(() => {
          closure_2_13.verbose("Unpausing Dispatch Queue");
          dispatcher = dispatcher.dispatcher;
          dispatcher.unpauseDispatchQueue();
        }, 100);
      } else {
        logger.verbose("Unpausing Dispatch Queue");
        const dispatcher2 = tmp3.dispatcher;
        dispatcher2.unpauseDispatchQueue();
      }
    } catch (tmp17) {
      logger.warn("Lazy cache has encountered error", tmp17);
      const obj2 = { type: "RESET_SOCKET", args: obj3 };
      obj3 = { error: tmp17, action: "LazyCache" };
      obj = closure_2_1(closure_2_2[23]);
      obj.dispatch(obj2);
    }
  });
  const tmp4 = dependencyMap;
  if (!tmp4) {
    const loadLazyCache = TTITrackerDefault.loadLazyCache;
    loadLazyCache.recordEnd();
  }
}
({ MAX_MESSAGES_PER_CHANNEL: c9, CACHE_STORE_KEY: c10, CACHE_STORE_LAZY_KEY: unpackModuleId, CACHE_STORE_CHANNELS_LAZY_KEY: closure_12 } = Constants);
let tmp3 = new LoggerDefault("CacheStore");
let c14 = false;
let initializing = "initializing";
let closure_16 = 0;
let c17 = false;
let c18 = false;
let c19 = false;
let c22 = false;
const Store = get_initializedDefault.Store;
class CacheStoreClass extends Store {
  initialize() {
    this.waitFor(AuthenticationStore, GatewayConnectionStore, SelectedChannelStore, SelectedGuildStore);
  }
  hasCache() {
    return c17;
  }
  getLazyCacheStatus() {
    return initializing;
  }
  canWriteCaches(flag) {
    obj = AuthenticationUtils;
    if (obj.isAuthenticated()) {
      let flag2;
      const tmp3 = c14;
      if (tmp3) {
        closure_13.log("Not writing cache because caches cleared");
        flag2 = false;
      } else {
        flag2 = !tmp5;
        if (!flag && !c19) {
          closure_13.log("Not writing cache because never connected");
          flag2 = false;
        }
      }
      flag = flag2;
    } else {
      closure_13.log("Not writing cache because not authenticated");
      flag = false;
    }
    return flag;
  }
  loadCacheAsync(arg0, arg1) {
    let closure_0 = arg0;
    let closure_1 = arg1;
    return (async (arg0, value) => {
      let obj8;
      let tmp;
      let v0;
      function loadLateLazyCache() {
        return closure_1_25(...arguments);
      }
      function dontLoadLateLazyCache() {
        let _true;
        const f152655 = () => {
          obj = closure_1(c2[23]);
          return obj.dispatch({ type: "CACHE_LOADED_LAZY_NO_CACHE" });
        };
        const socket = closure_5.getSocket();
        let c2 = false;
        const Emitter = socket(c2[22]).Emitter;
        Emitter.batched(function() {
          let dispatcher;
          let obj3;
          try {
            f152655();
            dispatcher = dispatcher.dispatcher;
            if (dispatcher.hasStuffToDispatchNow()) {
              let c2 = true;
              const loadLazyCache = closure_2_1(closure_2_2[12]).loadLazyCache;
              loadLazyCache.recordEnd();
              logger.verbose("Processing First Queued Dispatch");
              const dispatcher3 = tmp3.dispatcher;
              const _Set = Set;
              const self = this;
              const self2 = this;
              const processFirstQueuedDispatch = dispatcher3.processFirstQueuedDispatch;
              set = new Set(["READY", "INITIAL_GUILD"]);
              const result = processFirstQueuedDispatch(set);
              _setTimeout = setTimeout;
              const timerId = setTimeout(() => {
                closure_2_13.verbose("Unpausing Dispatch Queue");
                dispatcher = dispatcher.dispatcher;
                dispatcher.unpauseDispatchQueue();
              }, 100);
            } else {
              logger.verbose("Unpausing Dispatch Queue");
              const dispatcher2 = tmp3.dispatcher;
              dispatcher2.unpauseDispatchQueue();
            }
          } catch (tmp17) {
            logger.warn("Lazy cache has encountered error", tmp17);
            const obj2 = { type: "RESET_SOCKET", args: obj3 };
            obj3 = { error: tmp17, action: "LazyCache" };
            obj = closure_2_1(closure_2_2[23]);
            obj.dispatch(obj2);
          }
        });
        const tmp = socket;
        const tmp2 = c2;
        const tmp4 = c2;
        if (!tmp4) {
          let loadLazyCache = tmp(tmp2[12]).loadLazyCache;
          loadLazyCache.recordEnd();
        }
        return Promise.resolve();
      }
      if (c5 === 2) {
        c5 = 3;
        const str = "Generator functions may not be called on executing generators";
        throw new TypeError("Generator functions may not be called on executing generators");
      } else {
        const str2 = "cache:lazy_cache_not_initializing";
        const str3 = "initializing";
        if (tmp3 === 3) {
          if (arg0 === 1) {
            throw value;
          } else if (arg0 === 2) {
            let obj2 = { value, done: true };
            return obj2;
          } else {
            return { value: "IconComponent", done: null };
          }
        } else {
          let c3;
          let closure_2;
          try {
            let _setTimeout;
            let id;
            let closure_3;
            let closure_4;
            let closure_5;
            let closure_6;
            let closure_7;
            c5 = 2;
            let tmp4 = c4;
            if (0 === c4) {
              if (arg0 === 1) {
                c5 = 3;
                throw value;
              } else if (arg0 === 2) {
                c5 = 3;
                let obj3 = { value, done: true };
                return obj3;
              } else {
                _setTimeout = undefined;
                id = undefined;
                closure_2 = undefined;
                closure_3 = undefined;
                closure_4 = undefined;
                closure_5 = undefined;
                closure_6 = undefined;
                closure_7 = undefined;
                const obj13 = _setTimeout(closure_2[33]);
                const callOnceResult = obj13.callOnce(tmp);
                _setTimeout = callOnceResult;
                const obj14 = tmp(closure_2[12]);
                obj14.setInitialPage(_setTimeout.page);
                const guildId = _setTimeout.guildId;
                let tmp26 = null;
                const setInitialGuildId = tmp(closure_2[12]).setInitialGuildId;
                const tmp62 = tmp(closure_2[12]);
                if (null != guildId) {
                  tmp26 = null;
                  if ("@me" !== guildId) {
                    tmp26 = guildId;
                  }
                }
                setInitialGuildId(tmp26);
                if ("initializing" !== initializing) {
                  tmp(closure_2[21])("cache:lazy_cache_not_initializing");
                  callOnceResult();
                  _setTimeout = setTimeout;
                  let timerId = setTimeout(() => {
                    const socket = closure_1_5.getSocket();
                    let unpauseDispatchQueueResult;
                    if (socket != null) {
                      const dispatcher = socket.dispatcher;
                      if (dispatcher != null) {
                        unpauseDispatchQueueResult = dispatcher.unpauseDispatchQueue();
                      }
                    }
                    return unpauseDispatchQueueResult;
                  }, 0);
                  c5 = 3;
                  const obj4 = { value: undefined, done: true };
                  return obj4;
                } else {
                  c3 = 1;
                  id = id.getId();
                  const obj15 = tmp(closure_2[34]);
                  closure_2 = obj15.carefullyOpenDatabase(id);
                  const loadMiniCache = tmp(closure_2[12]).loadMiniCache;
                  c4 = 2;
                  c5 = 1;
                  const obj5 = {
                    value: loadMiniCache.measureAsync(async () => {
                                  function loadEarlyCache() {
                                    return closure_1_21(...arguments);
                                  }
                                  return loadEarlyCache(closure_1_2, closure_1_1, _setTimeout);
                                }),
                    done: false
                  };
                  return obj5;
                }
              }
            } else {
              if (1 === tmp4) {
                c3 = 0;
                const error = closure_2;
                logger.error("clearing cache. exception encountered while loading cache.", error, error.stack);
                const tmp17 = closure_2;
                tmp(closure_2[21])("cache:exception", error);
                const tmp21 = _setTimeout();
                const obj7 = { type: "RESET_SOCKET", args: obj8 };
                obj8 = { error, action: "loadCacheAsync" };
                const obj6 = tmp(closure_2[23]);
                const dispatchResult = obj6.dispatch(obj7);
              } else if (2 === tmp4) {
                if (arg0 === 1) {
                  c5 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c3 = 0;
                  c5 = 3;
                  const obj9 = { value, done: true };
                  return obj9;
                } else {
                  closure_3 = value;
                  closure_4 = c3(closure_3, 3);
                  closure_5 = closure_4[0];
                  closure_6 = closure_4[1];
                  closure_7 = closure_4[2];
                  _setTimeout();
                  if (closure_5) {
                    _setTimeout = loadLateLazyCache(closure_2, id, closure_6, closure_7);
                    c4 = 4;
                    c5 = 1;
                    const obj10 = { value: _setTimeout, done: false };
                    return obj10;
                  } else {
                    c4 = 3;
                    c5 = 1;
                    const obj11 = { value: dontLoadLateLazyCache(), done: false };
                    return obj11;
                  }
                }
              } else {
                if (3 === tmp4) {
                  if (arg0 === 1) {
                    c5 = 3;
                    throw value;
                  } else if (arg0 === 2) {
                    c3 = 0;
                    c5 = 3;
                    const obj12 = { value, done: true };
                    return obj12;
                  }
                } else if (arg0 === 1) {
                  c5 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c3 = 0;
                  c5 = 3;
                  obj = { value, done: true };
                  return obj;
                }
                c3 = 0;
              }
              c5 = 3;
              return { value: "IconComponent", done: null };
            }
          } catch (tmp34) {
            closure_2 = tmp34;
            if (0 === c3) {
              c5 = 3;
              throw tmp34;
            } else {
              c4 = 1;
            }
          }
        }
      }
    })();
  }
}
Object.defineProperty(CacheStoreClass.prototype, "lastWriteTime", {
  get: function lastWriteTime() {
    return closure_16;
  },
  set: undefined
});
CacheStoreClass.displayName = "CacheStore";
obj = {
  CONNECTION_OPEN: function handleConnectionOpen() {
    c18 = true;
    c19 = true;
    return false;
  },
  LOGOUT: handleClearCaches,
  CONNECTION_CLOSED: function handleConnectionClose() {
    c18 = false;
    c19 = true;
    return false;
  },
  CACHE_LOADED: function handleCacheLoaded() {
    c17 = true;
  },
  CACHE_LOADED_LAZY: function handleCacheLoadedLazy() {
    c17 = true;
    initializing = "cache-loaded";
  },
  CACHE_LOADED_LAZY_NO_CACHE: function handleCacheLoadedLazyNoCache() {
    initializing = "no-cache";
  },
  CLEAR_CACHES: handleClearCaches,
  WRITE_CACHES: function saveCaches() {
    closure_13.verbose("Writing cache now");
    closure_16 = Date.now();
    c17 = true;
    const Storage = Storage4.Storage;
    Storage.remove(authStore);
    const Storage2 = Storage4.Storage;
    Storage2.remove(closure_12);
    const Storage3 = Storage4.Storage;
    Storage3.remove(unpackModuleId);
  }
};
const cacheStoreClass = new CacheStoreClass(DispatcherDefault, obj);
let result = size.fileFinishedImporting("modules/cache/CacheStore.tsx");

export default cacheStoreClass;
export const ENABLE_CACHE_STORE = true;