// Module ID: 14578
// Function ID: 14579
// Name: LocalMessageCacheManager
// Dependencies: [5, 32, 4223, 502, 1957, 4795, 1074, 14579, 3, 1090, 510, 4166, 4255, 7766, 7470, 573, 11778, 11707, 1896, 1898, 5286, 9973, 2]

// Module 14578 (LocalMessageCacheManager)
import LoggerDefault from "Logger" /* 3 */;
import Storage3 from "Storage" /* 510 */;
import DispatcherDefault from "Dispatcher" /* 573 */;
import DurationsDefault from "Durations" /* 1090 */;
import _modDef4166 from "module_4166" /* 4166 */;
import DateUtils from "DateUtils" /* 4255 */;
import UploadActionCreatorsDefault from "UploadActionCreators" /* 11778 */;
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;
import _slicedToArray from "module_32" /* 32 */;
import MessageRecord from "MessageRecord" /* 4223 */;
import AuthenticationStore from "AuthenticationStore" /* 502 */;
import ChannelStore from "ChannelStore" /* 1957 */;
import MessageStore from "MessageStore" /* 4795 */;
import LifecycleManager from "LifecycleManager" /* 1898 */;

require = fn;
function _getKeyForFileId(arg0) {
  const entries = Object.entries(_getMessages());
  const obj = entries[Symbol.iterator]();
  while (obj !== undefined) {
    let tmp4 = _slicedToArray(tmp2, 2);
    let file = tmp4[1].file;
    let id;
    if (file != null) {
      id = file.id;
    }
    if (id === arg0) {
      obj.return();
      return tmp4[0];
    }
  }
}
function removeCachedMessage(arg0) {
  closure_0 = arg0;
  return closure_10(() => _writeMessage(c0, null));
}
function getAllCachedMessages() {
  return closure_10(_getMessages);
}
function messageTimestampIsInInterval(arg0, arg1) {
  if (null != arg0) {
    const tmp4 = _modDef4166();
    const tmp5 = _modDef4166(arg0);
    return DateUtils.isWithinInterval(tmp4, tmp5, arg1);
  } else {
    return false;
  }
}
function createFailedMessage(channel_id) {
  channel_id = channel_id.channel_id;
  ({ content, tts, state } = channel_id);
  const tmp3 = file(7766)({ channelId: channel_id, content, tts, state: MessageStates.SEND_FAILED });
  const id = tmp3;
  ({ timestamp: tmp3.timestamp, file } = channel_id);
  file(7470).receiveMessage(channel_id, tmp3, true, { isHydratingExpiredPendingMessage: state === MessageStates.SENDING });
  if (null != file) {
    file(573).wait(() => UploadActionCreatorsDefault.restoreFailedUpload(id.id, file));
    const tmpResult = file(573);
  }
}
function resumeSendingMessage() {
  const self = this;
  const apply = closure_24.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_24 = async function _resumeSendingMessage(arg0) {
  let channel_id = arg0;
  c4 = 0;
  c5 = 0;
  return (async (arg0, value) => {
    closure_3 = tmp5;
    closure_2 = tmp2;
    closure_130_0 = channel_id;
    ({ file, sendMessageOptions: closure_130_1 } = channel_id);
    channel = channel.getChannel(channel_id.channel_id);
    closure_130_2 = channel;
    if (null == channel) {
      return false;
    }
    if (file != null) {
      const items = file.items;
    }
    c1 = items;
    if (items == null) {
      c1 = undefined;
    }
    closure_130_3 = c1;
    await require("asyncRequireImpl")(paths[17], paths.paths);
    const merged = Object.assign(closure_130_0);
    value.default(closure_130_2, new closure_131_5({}), closure_130_3, closure_130_1);
    return true;
  })();
};
let closure_25 = async function _rehydrateFailedMessages(arg0, value) {
  if (c9 === 2) {
    c9 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp5 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c9 = 2;
      let keys = c8;
      if (0 === c8) {
        if (arg0 === 1) {
          c9 = 3;
          throw value;
        } else if (arg0 === 2) {
          c9 = 3;
          const obj3 = { value, done: true };
          return obj3;
        } else {
          closure_7 = tmp2;
          closure_6 = tmp3;
          closure_134_0 = closure_0;
          closure_134_1 = undefined;
          closure_134_2 = undefined;
          closure_134_3 = undefined;
          let timestamp;
          let state;
          c8 = 1;
          c9 = 1;
          const obj4 = { value: getAllCachedMessages(), done: false };
          return obj4;
        }
      } else {
        if (1 === keys) {
          if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 === 2) {
            c9 = 3;
            const obj5 = { value, done: true };
            return obj5;
          } else {
            closure_134_1 = value;
            const _Object = Object;
            const _HermesInternal4 = HermesInternal;
            closure_135_11.verbose("rehydrateFailedMessages with " + Object.keys(closure_134_1).length + " messagess");
            closure_2 = closure_134_1;
            keys = Object.keys();
            if (keys === undefined) {
              closure_4 = tmp67;
              closure_3 = tmp66;
              closure_2 = tmp63;
              importDefault = keys;
            } else {
              closure_4 = tmp67;
              closure_3 = tmp66;
              closure_2 = tmp65;
              importDefault = keys;
            }
            c9 = 3;
            tmp65 = closure_134_1;
          }
        } else if (arg0 === 1) {
          c9 = 3;
          throw value;
        } else if (arg0 === 2) {
          c9 = 3;
          const obj = { value, done: true };
          return obj;
        }
        while (importDefault[closure_3] !== undefined) {
          closure_5 = tmp12;
          closure_4 = tmp10;
          closure_3 = tmp9;
          closure_2 = tmp8;
          importDefault = tmp7;
          closure_134_2 = tmp12;
          closure_134_3 = closure_134_1[closure_134_2];
          if (closure_134_3.channel_id !== closure_134_0) {
            continue;
          } else {
            let tmp17 = closure_135_19(closure_134_2);
            if (null != closure_135_8.getMessage(closure_134_0, closure_134_3.id)) {
              continue;
            } else {
              timestamp = closure_134_3.timestamp;
              state = closure_134_3.state;
              if (closure_135_21(timestamp, closure_135_14)) {
                if (state === closure_135_9.SENDING) {
                  if (closure_135_21(timestamp, closure_135_13)) {
                    let tmp45 = globalThis;
                    let _JSON2 = JSON;
                    let _HermesInternal3 = HermesInternal;
                    let str3 = "sending message with data ";
                    let verboseResult1 = closure_135_11.verbose("sending message with data " + JSON.stringify(closure_134_3));
                    c8 = 2;
                    c9 = 1;
                    let obj6 = { value: closure_135_23(closure_134_3), done: false };
                    return obj6;
                  }
                }
                let tmp36 = globalThis;
                let _JSON = JSON;
                let _HermesInternal2 = HermesInternal;
                let str2 = "failed message with data ";
                let infoResult = closure_135_11.info("failed message with data " + JSON.stringify(closure_134_3));
                let tmp41 = closure_135_22(closure_134_3);
                continue;
              } else {
                let tmp24 = globalThis;
                let _HermesInternal = HermesInternal;
                let str = "dropping stale message, timestamp ";
                let verboseResult2 = closure_135_11.verbose("dropping stale message, timestamp " + timestamp);
                continue;
              }
              continue;
            }
            continue;
          }
          continue;
        }
        closure_5 = tmp12;
        closure_4 = tmp10;
        closure_3 = tmp9;
        closure_2 = tmp8;
        importDefault = tmp7;
      }
    } catch (tmp52) {
      c9 = tmp;
      throw tmp52;
    }
  }
};
const MessageStates = fn(1074).MessageStates;
const MutexUtils = fn(14579);
let closure_10 = MutexUtils.createLock();
let closure_11 = new LoggerDefault("LocalMessageCacheManager");
const LocalMessageCacheManagerMessageCacheKey = "LocalMessageCacheManagerMessageCacheKey";
let closure_13 = 5 * DurationsDefault.Millis.MINUTE;
let closure_14 = 14 * DurationsDefault.Millis.DAY;
function _getMessages() {
  const Storage = Storage3.Storage;
  let obj = Storage.get(LocalMessageCacheManagerMessageCacheKey);
  if (null == obj) {
    obj = {};
  }
  return obj;
}
function _getMessage(arg0) {

}
function _writeMessage(arg0, id) {
  id = undefined;
  if (id != null) {
    id = id.id;
  }
  let channel_id;
  if (id != null) {
    channel_id = id.channel_id;
  }
  closure_11.verbose("_writeMessage", id, channel_id);
  if (typeof _getMessages === "function") {
    const Storage = Storage3.Storage;
    let obj2 = Storage.get(LocalMessageCacheManagerMessageCacheKey);
    if (null == obj2) {
      obj2 = {};
    }
    if (null != id) {
      const obj3 = {};
      const merged = Object.assign(id);
      let str = id.content;
      if (str == null) {
        str = "";
      }
      obj3.content = str;
      obj2[arg0] = obj3;
      obj.verbose("_writeMessage after write", obj2[arg0].id, obj2[arg0].channel_id);
    } else {
      delete tmp[tmp2];
    }
    const Storage2 = Storage3.Storage;
    const result = Storage2.set(LocalMessageCacheManagerMessageCacheKey, obj2);
    return obj2;
  } else {
    throw new TypeError("Trying to call a non-function");
  }
  obj = closure_11;
}
class LocalMessageCacheManager extends tmp3 {
  constructor() {
    applyArgumentsResult = HermesBuiltin.applyArguments(new.target, new.target);
    closure_0 = applyArgumentsResult;
    tmp3 = _e;
    set = new Set();
    if (_e in applyArgumentsResult) {
      str = "Cannot initialize private field twice.";
      throw new TypeError("Cannot initialize private field twice.");
    } else {
      tmp5 = set;
      applyArgumentsResult[set] = tmp3;
      tmp6 = closure_3;
      applyArgumentsResult.handlePostConnectionOpen = closure_3(async (arg0, value) => {
        if (c10 === 2) {
          c10 = 3;
          throw new TypeError("Generator functions may not be called on executing generators");
        } else if (tmp7 === 3) {
          if (arg0 === 1) {
            throw value;
          } else if (arg0 === 2) {
            let obj2 = { value, done: true };
            return obj2;
          } else {
            return { value: "HermesInternal", done: null };
          }
        } else {
          try {
            c10 = 2;
            if (0 === c9) {
              if (arg0 === 1) {
                c10 = 3;
                throw value;
              } else if (arg0 === 2) {
                c10 = 3;
                const obj3 = { value, done: true };
                return obj3;
              } else {
                closure_6 = tmp8;
                closure_134_0 = undefined;
                closure_134_1 = undefined;
                closure_134_2 = undefined;
                let channel_id;
                let state;
                c9 = 1;
                c10 = 1;
                const obj4 = { value: getAllCachedMessages(), done: false };
                return obj4;
              }
            } else {
              if (1 === tmp8) {
                if (arg0 === 1) {
                  c10 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c10 = 3;
                  const obj5 = { value, done: true };
                  return obj5;
                } else {
                  closure_134_0 = value;
                  closure_134_1 = async function _loop(arg0, value) {
                    if (c1 === 2) {
                      c1 = 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: "HermesInternal", done: null };
                      }
                    } else {
                      try {
                        c1 = 2;
                        if (arg0 === 1) {
                          c1 = 3;
                          throw value;
                        } else if (arg0 === 2) {
                          c1 = 3;
                          const obj = { value, done: true };
                          return obj;
                        } else {
                          if (next === constants.SENDING) {
                            const _setTimeout = setTimeout;
                            const timerId = setTimeout(() => {
                              const messages = c1(closure_2_2[21]).fetchMessages({ channelId });
                            }, 0);
                          }
                          c1 = 3;
                          return { value: "HermesInternal", done: null };
                        }
                      } catch (tmp9) {
                        c1 = tmp;
                        throw tmp9;
                      }
                    }
                  };
                  const _Object = Object;
                  const values = Object.values(closure_134_0);
                  applyArgumentsResult = values[Symbol.iterator]();
                  if (applyArgumentsResult === undefined) {
                    c10 = 3;
                    return { value: "HermesInternal", done: null };
                  } else {
                    c7 = 1;
                    closure_134_2 = tmp34;
                    channel_id = closure_134_2.channel_id;
                    state = closure_134_2.state;
                    const iter4 = closure_134_1(channel_id)[tmp48.iterator]();
                    HermesBuiltin.ensureObject("iterator is not an object");
                    const next = iter4.next;
                    closure_2 = undefined;
                    const tmp59 = closure_134_1(channel_id);
                  }
                }
              } else if (2 === tmp8) {
                c7 = 0;
                applyArgumentsResult.return();
                throw closure_8;
              } else {
                if (3 === tmp8) {
                  c7 = 2;
                  if (arg0 === 1) {
                    c10 = 3;
                    throw value;
                  } else {
                    closure_2 = value;
                    if (arg0 === 2) {
                      closure_2 = value;
                      c7 = 1;
                      const method = HermesBuiltin.getMethod("return");
                      if (method === undefined) {
                        c7 = 0;
                        applyArgumentsResult.return();
                        c10 = 3;
                        const obj6 = { value, done: true };
                        return obj6;
                      } else {
                        const iter2 = method(closure_2);
                        HermesBuiltin.ensureObject("iterator.return() did not return an object");
                        if (iter2.done) {
                          c7 = 0;
                          applyArgumentsResult.return();
                          c10 = 3;
                          let obj = { value: iter2.value, done: true };
                          return obj;
                        } else {
                          c9 = 3;
                          c10 = 1;
                          return iter2;
                        }
                      }
                    } else {
                      c7 = 1;
                      const tmp20 = value;
                    }
                  }
                } else {
                  c7 = 1;
                  const method1 = HermesBuiltin.getMethod("throw");
                  if (method1 === undefined) {
                    const method2 = HermesBuiltin.getMethod("return");
                    if (method2 !== undefined) {
                      HermesBuiltin.ensureObject("iterator.return() did not return an object");
                    }
                    throw new TypeError("yield* delegate must have a .throw() method");
                  } else {
                    const iter = method1(tmp10);
                    HermesBuiltin.ensureObject("iterator.throw() did not return an object");
                    if (iter.done) {
                      let iter3 = iter;
                    } else {
                      c9 = 3;
                      c10 = 1;
                      return iter;
                    }
                  }
                  tmp10 = closure_8;
                }
                value = iter3.value;
                c7 = 0;
              }
              iter3 = next(tmp20);
              HermesBuiltin.ensureObject("iterator.next() did not return an object");
              if (!iter3.done) {
                c9 = 3;
                c10 = 1;
                return iter3;
              }
            }
          } catch (tmp41) {
            closure_8 = tmp41;
            if (tmp4 === c7) {
              c10 = tmp3;
              throw tmp41;
            } else if (tmp2 === tmp43) {
              c9 = tmp;
            } else {
              c9 = tmp5;
            }
          }
        }
      });
      applyArgumentsResult.handleMessageDelete = function handleMessageDelete(id) {
        id = id.id;
        closure_10(() => {
          const tmp = (function _getKeyForMessageId(id) {
            const entries = Object.entries(closure_1_15());
            const obj = entries[Symbol.iterator]();
            while (obj !== undefined) {
              let tmp4 = closure_1_4(tmp2, 2);
              if (tmp4[1].id === id) {
                obj.return();
                return tmp5;
              }
            }
          })(id);
          if (null != tmp) {
            _writeMessage(tmp, null);
          }
        });
      };
      applyArgumentsResult.handleLogout = function handleLogout() {
        !closure_1_10(() => {
          const Storage = closure_1_0(closure_1_2[10]).Storage;
          return Storage.remove(closure_1_12);
        });
      };
      applyArgumentsResult.handleMessageCreate = function handleMessageCreate(message) {
        message = message.message;
        const author = message.author;
        let id1;
        if (author != null) {
          id1 = author.id;
        }
        if (id1 === AuthenticationStore.getId()) {
          let id = message.nonce;
          if (id == null) {
            id = message.id;
          }
          if (message.state !== MessageStates.SENDING) {
            if (message.state !== tmp2.SEND_FAILED) {
              c0 = id;
              closure_10(() => _writeMessage(c0, null));
            }
          }
          applyArgumentsResult.#e.add(message.channel_id);
          const obj2 = { key: id, message, sendMessageOptions: message.sendMessageOptions };
          c0 = undefined;
          c1 = undefined;
          c2 = undefined;
          ({ key: c0, message: message2, file: c1, sendMessageOptions: c2 } = obj2);
          c3 = undefined;
          c4 = undefined;
          c5 = undefined;
          c6 = undefined;
          c7 = undefined;
          c8 = undefined;
          c9 = undefined;
          c10 = undefined;
          c11 = undefined;
          ({ content: c3, id: c4, channel_id: c5, tts: c6, nonce: c7, timestamp: c8, type: c9, flags: c10, state: c11 } = message2);
          closure_10(() => {
            if (typeof _getMessage === "function") {
              if (typeof _getMessages === "function") {
                const Storage = applyArgumentsResult(dependencyMap[10]).Storage;
                let obj = Storage.get(LocalMessageCacheManagerMessageCacheKey);
                if (null == obj) {
                  obj = {};
                }
                const obj2 = { content, type, state: null, channel_id: null, tts: null, id: null, nonce: null, timestamp: null, flags: null, file: null, sendMessageOptions: null };
                let SENDING = c11;
                if (c11 == null) {
                  SENDING = constants.SENDING;
                }
                obj2.state = SENDING;
                obj2.channel_id = channel_id;
                obj2.tts = tts;
                obj2.id = id;
                obj2.nonce = nonce;
                let toISOStringResult = _undefined;
                if (typeof _undefined !== "string") {
                  toISOStringResult = _undefined.toISOString();
                }
                obj2.timestamp = toISOStringResult;
                obj2.flags = flags;
                let tmp18 = closure_1_1;
                if (closure_1_1 == null) {
                  let file;
                  if (tmp7 != null) {
                    file = tmp7.file;
                  }
                  tmp18 = file;
                }
                obj2.file = tmp18;
                let obj4 = closure_1_2;
                if (null != closure_1_2) {
                  if (obj4 == null) {
                    obj4 = {};
                  }
                  const obj5 = {};
                  const merged = Object.assign(obj4);
                  let sendMessageOptions = obj5;
                } else if (tmp7 != null) {
                  sendMessageOptions = tmp7.sendMessageOptions;
                }
                obj2.sendMessageOptions = sendMessageOptions;
                _writeMessage(tmp, obj2);
              } else {
                throw new TypeError("Trying to call a non-function");
              }
            } else {
              throw new TypeError("Trying to call a non-function");
            }
          });
        }
      };
      applyArgumentsResult.handleLoadMessagesSuccess = function handleLoadMessagesSuccess(channelId) {
        applyArgumentsResult.handleChannelLoaded(channelId.channelId);
      };
      applyArgumentsResult.handleCacheLoaded = function handleCacheLoaded(arg0) {
        const items = [, ];
        ({ privateChannels: arr[0], initialGuildChannels: arr[1] } = arg0);
        for (const item10008 of items) {
          for (const item10013 of item10008) {
            let handleChannelLoadedResult = applyArgumentsResult.handleChannelLoaded(item10013.id);
            continue;
          }
          continue;
        }
      };
      closure_129_0 = undefined;
      closure_129_1 = applyArgumentsResult;
      closure_129_0 = closure_3(async (arg0, value) => {
        if (c1 === 2) {
          c1 = 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 obj3 = { value, done: true };
            return obj3;
          } else {
            return { value: "HermesInternal", done: null };
          }
        } else {
          try {
            c1 = 2;
            if (0 === c2) {
              if (arg0 === 1) {
                c1 = 3;
                throw value;
              } else if (arg0 === 2) {
                c1 = 3;
                const obj4 = { value, done: true };
                return obj4;
              } else if (!importDefault[closure_1_26].has(closure_0)) {
                obj2.add(tmp5);
                c2 = 1;
                c1 = 1;
                const obj5 = {
                  value: (function rehydrateFailedMessages() {
                            const self = this;
                            const apply = closure_1_25.apply;
                            if (typeof apply === "unknown") {
                              applyArgumentsResult = HermesBuiltin.applyArguments(self);
                            } else {
                              applyArgumentsResult = apply(self, arguments);
                            }
                            return applyArgumentsResult;
                          })(tmp5),
                  done: false
                };
                return obj5;
              }
            } else if (arg0 === 1) {
              c1 = 3;
              throw value;
            } else if (arg0 === 2) {
              c1 = 3;
              const obj = { value, done: true };
              return obj;
            }
            c1 = 3;
            return { value: "HermesInternal", done: null };
          } catch (tmp9) {
            c1 = tmp;
            throw tmp9;
          }
        }
      });
      applyArgumentsResult.handleChannelLoaded = function(arg0) {
        const self = this;
        const apply = applyArgumentsResult.apply;
        if (typeof apply === "unknown") {
          applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
      applyArgumentsResult.handleFileUploadStart = function handleFileUploadStart(message) {
        message = message.message;
        if (null != message) {
          let id = message.nonce;
          if (id == null) {
            id = message.id;
          }
          let obj = { key: id, message, file: tmp };
          ({ key: closure_0, message: message2, file: closure_1, sendMessageOptions: closure_2 } = obj);
          c3 = undefined;
          c4 = undefined;
          c5 = undefined;
          c6 = undefined;
          c7 = undefined;
          c8 = undefined;
          c9 = undefined;
          c10 = undefined;
          c11 = undefined;
          ({ content: c3, id: c4, channel_id: c5, tts: c6, nonce: c7, timestamp: c8, type: c9, flags: c10, state: c11 } = message2);
          c10(() => {
            if (typeof _getMessage === "function") {
              if (typeof _getMessages === "function") {
                const Storage = applyArgumentsResult(dependencyMap[10]).Storage;
                let obj = Storage.get(LocalMessageCacheManagerMessageCacheKey);
                if (null == obj) {
                  obj = {};
                }
                const obj2 = { content, type, state: null, channel_id: null, tts: null, id: null, nonce: null, timestamp: null, flags: null, file: null, sendMessageOptions: null };
                let SENDING = c11;
                if (c11 == null) {
                  SENDING = constants.SENDING;
                }
                obj2.state = SENDING;
                obj2.channel_id = channel_id;
                obj2.tts = tts;
                obj2.id = id;
                obj2.nonce = nonce;
                let toISOStringResult = _undefined;
                if (typeof _undefined !== "string") {
                  toISOStringResult = _undefined.toISOString();
                }
                obj2.timestamp = toISOStringResult;
                obj2.flags = flags;
                let tmp18 = closure_1_1;
                if (closure_1_1 == null) {
                  let file;
                  if (tmp7 != null) {
                    file = tmp7.file;
                  }
                  tmp18 = file;
                }
                obj2.file = tmp18;
                let obj4 = closure_1_2;
                if (null != closure_1_2) {
                  if (obj4 == null) {
                    obj4 = {};
                  }
                  const obj5 = {};
                  const merged = Object.assign(obj4);
                  let sendMessageOptions = obj5;
                } else if (tmp7 != null) {
                  sendMessageOptions = tmp7.sendMessageOptions;
                }
                obj2.sendMessageOptions = sendMessageOptions;
                _writeMessage(tmp, obj2);
              } else {
                throw new TypeError("Trying to call a non-function");
              }
            } else {
              throw new TypeError("Trying to call a non-function");
            }
          });
        }
      };
      applyArgumentsResult.handleUploadProgress = function handleUploadProgress(file) {
        file = file.file;
        closure_10(() => {
          const tmp2 = _getKeyForFileId(file.id);
          if (null != tmp2) {
            let obj = { file };
            closure_0 = tmp2;
            closure_2_10(() => {
              if (typeof closure_2_16 === "function") {
                if (typeof closure_2_15 === "function") {
                  const Storage = file(closure_2_2[10]).Storage;
                  obj = Storage.get(closure_2_12);
                  if (null == obj) {
                    obj = {};
                  }
                  if (null != obj[tmp]) {
                    const obj2 = {};
                    const merged = Object.assign(tmp7);
                    const merged1 = Object.assign(obj);
                    closure_2_17(tmp, obj2);
                  }
                } else {
                  throw new TypeError("Trying to call a non-function");
                }
              } else {
                throw new TypeError("Trying to call a non-function");
              }
            });
          }
        });
      };
      applyArgumentsResult.handleUploadComplete = function handleUploadComplete(aborted) {
        if (aborted.aborted) {
          const file = aborted.file;
          closure_10(() => {
            const tmp = _getKeyForFileId(file.id);
            if (null != tmp) {
              _writeMessage(tmp, null);
            }
          });
        }
      };
      applyArgumentsResult.handleRestoreFailedUpload = function handleRestoreFailedUpload(file) {
        const obj = { file: file.file };
        const messageId = file.messageId;
        closure_10(() => {
          if (typeof closure_2_16 === "function") {
            if (typeof closure_2_15 === "function") {
              const Storage = file(closure_2_2[10]).Storage;
              obj = Storage.get(closure_2_12);
              if (null == obj) {
                obj = {};
              }
              if (null != obj[tmp]) {
                const obj2 = {};
                const merged = Object.assign(tmp7);
                const merged1 = Object.assign(obj);
                closure_2_17(tmp, obj2);
              }
            } else {
              throw new TypeError("Trying to call a non-function");
            }
          } else {
            throw new TypeError("Trying to call a non-function");
          }
        });
      };
      applyArgumentsResult.handleTextMessageFailed = function handleTextMessageFailed(messageId) {
        const obj = { state: constants.SEND_FAILED };
        messageId = messageId.messageId;
        closure_10(() => {
          if (typeof closure_2_16 === "function") {
            if (typeof closure_2_15 === "function") {
              const Storage = file(closure_2_2[10]).Storage;
              obj = Storage.get(closure_2_12);
              if (null == obj) {
                obj = {};
              }
              if (null != obj[tmp]) {
                const obj2 = {};
                const merged = Object.assign(tmp7);
                const merged1 = Object.assign(obj);
                closure_2_17(tmp, obj2);
              }
            } else {
              throw new TypeError("Trying to call a non-function");
            }
          } else {
            throw new TypeError("Trying to call a non-function");
          }
        });
      };
      return applyArgumentsResult;
    }
  }
}
const prototype = LocalMessageCacheManager.prototype;
prototype["_terminate"] = function _terminate() {
  DispatcherDefault.unsubscribe("LOGOUT", this.handleLogout);
  DispatcherDefault.unsubscribe("MESSAGE_CREATE", this.handleMessageCreate);
  DispatcherDefault.unsubscribe("MESSAGE_SEND_FAILED", this.handleTextMessageFailed);
  DispatcherDefault.unsubscribe("UPLOAD_START", this.handleFileUploadStart);
  DispatcherDefault.unsubscribe("MESSAGE_DELETE", this.handleMessageDelete);
  DispatcherDefault.unsubscribe("UPLOAD_RESTORE_FAILED_UPLOAD", this.handleRestoreFailedUpload);
  DispatcherDefault.unsubscribe("UPLOAD_COMPLETE", this.handleUploadComplete);
  DispatcherDefault.unsubscribe("UPLOAD_PROGRESS", this.handleUploadProgress);
  DispatcherDefault.unsubscribe("LOAD_MESSAGES_SUCCESS", this.handleLoadMessagesSuccess);
  DispatcherDefault.unsubscribe("CACHE_LOADED", this.handleCacheLoaded);
  DispatcherDefault.unsubscribe("POST_CONNECTION_OPEN", this.handlePostConnectionOpen);
};
prototype["_initialize"] = function _initialize() {
  const self = this;
  closure_11.verbose("cache manager initialize");
  let subscription = DispatcherDefault.subscribe("LOGOUT", this.handleLogout);
  let subscription1 = DispatcherDefault.subscribe("MESSAGE_CREATE", this.handleMessageCreate);
  const subscription2 = DispatcherDefault.subscribe("MESSAGE_SEND_FAILED", this.handleTextMessageFailed);
  const subscription3 = DispatcherDefault.subscribe("UPLOAD_START", this.handleFileUploadStart);
  const subscription4 = DispatcherDefault.subscribe("MESSAGE_DELETE", this.handleMessageDelete);
  const subscription5 = DispatcherDefault.subscribe("UPLOAD_RESTORE_FAILED_UPLOAD", this.handleRestoreFailedUpload);
  const subscription6 = DispatcherDefault.subscribe("UPLOAD_COMPLETE", this.handleUploadComplete);
  const subscription7 = DispatcherDefault.subscribe("UPLOAD_PROGRESS", this.handleUploadProgress);
  const subscription8 = DispatcherDefault.subscribe("POST_CONNECTION_OPEN", this.handlePostConnectionOpen);
  (async (arg0, value) => {
    if (c8 === 2) {
      c8 = 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: "HermesInternal", done: null };
      }
    } else {
      while (true) {
        c8 = 2;
        let tmp4 = c7;
        if (0 === c7) {
          if (arg0 === 1) {
            c8 = 3;
            throw value;
          } else if (arg0 === 2) {
            c8 = 3;
            let obj5 = { value, done: true };
            return obj5;
          } else {
            closure_4 = tmp;
            closure_3 = tmp4;
            closure_131_0 = undefined;
            closure_131_1 = undefined;
            let channel_id;
            closure_131_3 = undefined;
            let ready;
            let cached;
            c7 = 1;
            c8 = 1;
            let obj6 = { value: getAllCachedMessages(), done: false };
            return obj6;
          }
        } else {
          if (1 === tmp4) {
            if (arg0 === 1) {
              c8 = 3;
              throw value;
            } else if (arg0 === 2) {
              c8 = 3;
              let obj7 = { value, done: true };
              return obj7;
            } else {
              closure_131_0 = value;
              let _Object = Object;
              let _HermesInternal2 = HermesInternal;
              let verboseResult = closure_1_11.verbose("initialized with " + Object.keys(closure_131_0).length + " messages in local cache");
              let _Object2 = Object;
              let values = Object.values(closure_131_0);
              _self = values[Symbol.iterator]();
              if (_self === undefined) {
                let obj3 = values(573);
                let subscription = obj3.subscribe("LOAD_MESSAGES_SUCCESS", closure_132_0.handleLoadMessagesSuccess);
                let obj4 = values(573);
                let subscription1 = obj4.subscribe("CACHE_LOADED", closure_132_0.handleCacheLoaded);
                c8 = 3;
                return { value: "HermesInternal", done: null };
              } else {
                c6 = 1;
                closure_131_1 = tmp10;
                channel_id = closure_131_1.channel_id;
                let obj9 = values(5286);
                value = obj9.get(channel_id);
                dependencyMap = value;
                if (value == null) {
                  dependencyMap = { ready: false, cached: false };
                }
                closure_131_3 = dependencyMap;
                ready = closure_131_3.ready;
                cached = closure_131_3.cached;
                let _HermesInternal = HermesInternal;
                let str = "rehydrating cached messages ";
                let str2 = " {ready: ";
                let str3 = ", cached: ";
                let str4 = "}";
                let verboseResult1 = closure_1_11.verbose("rehydrating cached messages " + channel_id + " {ready: " + ready + ", cached: " + cached + "}");
                if (ready) {
                  let verboseResult2 = closure_1_11.verbose("manually invoking handleChannelLoaded");
                  c7 = 3;
                  c8 = 1;
                  let obj8 = { value: closure_132_0.handleChannelLoaded(channel_id), done: false };
                  return obj8;
                }
              }
            }
          } else if (2 === tmp4) {
            c6 = 0;
            _self.return();
            throw MessageRecord;
          } else if (arg0 === 1) {
            c8 = 3;
            throw value;
          } else if (arg0 === 2) {
            c6 = 0;
            _self.return();
            c8 = 3;
            let obj = { value, done: true };
            return obj;
          }
          c6 = 0;
        }
      }
    }
  })();
};
const localMessageCacheManager = new LocalMessageCacheManager();
const size = fn(2);
let result = size.fileFinishedImporting("modules/local_message_caching/LocalMessageCacheManager.native.tsx");

export default localMessageCacheManager;