// Module ID: 6698
// Function ID: 51960
// Name: _createForOfIteratorHelperLoose
// Dependencies: []

// Module 6698 (_createForOfIteratorHelperLoose)
function _createForOfIteratorHelperLoose(@@iterator) {
  let arg1 = Symbol_iterator;
  @@iterator = "undefined" !== typeof Symbol;
  if (Symbol_iterator) {
    const _Symbol = Symbol;
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (!Symbol_iterator) {
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (Symbol_iterator) {
    const iter = Symbol_iterator.call(Symbol_iterator);
    const next = iter.next;
    return next.bind(iter);
  } else {
    const _Array = Array;
    let tmp = Symbol_iterator;
    if (!Array.isArray(Symbol_iterator)) {
      let tmp2;
      if (Symbol_iterator) {
        if ("string" === typeof Symbol_iterator) {
          tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
        } else {
          const toString = {}.toString;
          const substr = toString.call(Symbol_iterator).slice(8, -1);
          let name = substr;
          if (tmp3) {
            name = Symbol_iterator.constructor.name;
          }
          if ("Map" !== name) {
            if ("Set" !== name) {
              if ("Arguments" === name) {
                let arr = _arrayLikeToArray(Symbol_iterator, undefined);
              } else {
                const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
              }
            }
            tmp2 = arr;
          }
          const _Array2 = Array;
          arr = Array.from(Symbol_iterator);
          const callResult = toString.call(Symbol_iterator);
          const tmp3 = "Object" === substr && Symbol_iterator.constructor;
        }
      }
      tmp = tmp2;
      if (!tmp2) {
        const _TypeError = TypeError;
        const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
        throw typeError;
      }
    }
    if (tmp) {
      arg1 = tmp;
    }
    let closure_1 = 0;
    return () => {
      if (closure_1 >= tmp.length) {
        let obj = { done: true };
      } else {
        obj = { done: false };
        closure_1 = tmp3 + 1;
        obj.value = tmp[+closure_1];
      }
      return obj;
    };
  }
}
function _arrayLikeToArray(arg0, arg1) {
  let length;
  if (tmp) {
    length = arg0.length;
  }
  const ArrayResult = Array(length);
  for (let num = 0; num < length; num = num + 1) {
    ArrayResult[num] = arg0[num];
  }
  return ArrayResult;
}
function isLikelyNotDelta(author) {
  return null != author.author && null != author.content && null != author.mentions && null != author.timestamp;
}
let closure_3 = importDefault(dependencyMap[0]);
let closure_4 = importDefault(dependencyMap[1]);
let closure_5 = importDefault(dependencyMap[2]);
let closure_6 = importDefault(dependencyMap[3]);
let closure_7 = importDefault(dependencyMap[4]);
let closure_8 = importDefault(dependencyMap[5]);
let closure_9 = importDefault(dependencyMap[6]);
let importDefaultResult = importDefault(dependencyMap[7]);
importDefaultResult = new importDefaultResult("Messages");
const tmp4 = () => {
  class ChannelHistory {
    constructor(arg0) {
      self = this;
      tmp = closure_5(this, ChannelHistory);
      this.connectionId = null;
      this.users = [];
      this.members = [];
      this.messages = [];
      if (arg0.length > 0) {
        first = arg0[0];
        connectionId = undefined;
        if (null != first) {
          connectionId = first.connectionId;
        }
        ChannelHistory = connectionId;
        tmp3 = ChannelHistory;
        tmp4 = closure_4;
        num = 2;
        tmp5 = closure_4(ChannelHistory.computeUsersAndMembers(arg0), 2);
        num2 = 1;
        everyResult = arg0.length > 0;
        [tmp6, tmp7] = tmp5;
        if (everyResult) {
          everyResult = arg0.every((connectionId) => connectionId.connectionId === connectionId);
        }
        if (everyResult) {
          self.connectionId = connectionId;
        }
        self.users = tmp6;
        self.members = tmp7;
        self.messages = arg0.map((message) => message.message);
      }
      return;
    }
  }
  const arg1 = ChannelHistory;
  let obj = {
    key: "computeUsersAndMembers",
    value(messages) {
      let done;
      const self = this;
      const result = ChannelHistory(closure_2[8]).requireSortedDescending(messages);
      const map = new Map();
      const map1 = new Map();
      const tmp2 = callback3(messages);
      let iter = tmp2();
      if (!iter.done) {
        do {
          let value = iter.value;
          let addIntoMapResult = self.addIntoMap(map, value.users, (id) => id.id);
          let addIntoMapResult1 = self.addIntoMap(map1, value.members, (userId) => userId.userId);
          let iter2 = tmp2();
          iter = iter2;
          done = iter2.done;
        } while (!done);
      }
      const items = [Array.from(map.values()), Array.from(map1.values())];
      return items;
    }
  };
  const items = [obj, ];
  obj = {
    key: "addIntoMap",
    value(get) {
      let iter2;
      const tmp = callback3(arg1);
      let iter = tmp();
      if (!iter.done) {
        do {
          let value = iter.value;
          let tmp2 = arg2(value);
          value = get.get(tmp2);
          let tmp4 = null == value;
          if (!tmp4) {
            let tmp5 = value.incomplete && !value.incomplete;
            tmp4 = tmp5;
          }
          if (tmp4) {
            let result = get.set(tmp2, value);
          }
          iter2 = tmp();
          iter = iter2;
        } while (!iter2.done);
      }
    }
  };
  items[1] = obj;
  return callback2(ChannelHistory, null, items);
}();
let tmp5 = () => {
  class Messages {
    constructor() {
      f52003 = this;
      tmp = closure_5(this, Messages);
      this.actions = {
        CHANNEL_DELETE(arg0, arg1) {
              return self.handleChannelDelete(arg0, arg1);
            },
        GUILD_DELETE(arg0, arg1) {
              return self.handleGuildDelete(arg0, arg1);
            },
        LOAD_MESSAGES_SUCCESS(arg0, arg1) {
              return self.handleLoadMessagesSuccess(arg0, arg1);
            },
        MESSAGE_CREATE(arg0, arg1) {
              return self.handleMessageCreate(arg0, arg1);
            },
        MESSAGE_DELETE_BULK(arg0, arg1) {
              return self.handleMessageDeleteBulk(arg0, arg1);
            },
        MESSAGE_DELETE(arg0, arg1) {
              return self.handleMessageDelete(arg0, arg1);
            },
        MESSAGE_PREVIEWS_LOADED(arg0, arg1) {
              return self.handleMessagePreviewsLoaded(arg0, arg1);
            },
        MESSAGE_UPDATE(arg0, arg1) {
              return self.handleMessageUpdate(arg0, arg1);
            }
      };
      return;
    }
  }
  const callback = Messages;
  let obj = { key: "startupLoad" };
  let closure_2 = callback(async (arg0, arg1, arg2, arg3) => {
    const obj = callback(closure_2[9]);
    const messagesResult = callback(closure_2[9]).messages(arg0);
    const tmp = yield callback(closure_2[9]).messages(arg0).getLatest(arg1, arg2, arg3);
    return new closure_11(yield callback(closure_2[9]).messages(arg0).getLatest(arg1, arg2, arg3));
  });
  obj.value = function startupLoad(arg0, guildId, channelId, arg3) {
    return callback3(...arguments);
  };
  const items = [obj, , , , , , , , , , , , , , , , , , ];
  obj = { key: "load" };
  let closure_1 = callback(async (arg0, arg1, arg2) => {
    const basicChannel = basicChannel.getBasicChannel(arg1);
    if (null != arg1) {
      if (null != basicChannel) {
        if (obj.isReadableChannel(basicChannel)) {
          const obj2 = callback2(closure_2[9]);
          const tmp9 = yield callback2(closure_2[9]).messages(arg0).getLatest(basicChannel.guild_id, arg1, arg2);
          const prototype = ctor.prototype;
          const tmp14 = new ctor(tmp9);
          return tmp14;
        }
        const obj = callback(closure_2[10]);
      }
    }
    return new ctor([]);
  });
  obj.value = function load() {
    return callback2(...arguments);
  };
  items[1] = obj;
  obj = {
    key: "handleMessageCreate",
    value(optimistic) {
      const self = this;
      let tmp = optimistic.optimistic || optimistic.isPushNotification;
      if (!tmp) {
        tmp = null != optimistic.sendMessageOptions;
      }
      if (!tmp) {
        if (obj.isReadableChannelId(optimistic.channelId)) {
          self.upsertOne(optimistic.guildId, optimistic.channelId, optimistic.message, arg1);
        }
        const obj = callback(closure_2[10]);
      }
    }
  };
  items[2] = obj;
  items[3] = {
    key: "handleMessageUpdate",
    value(message) {
      const self = this;
      let isReadableChannelIdResult = null != message.message.id && null != message.message.channel_id;
      if (isReadableChannelIdResult) {
        isReadableChannelIdResult = callback(closure_2[10]).isReadableChannelId(message.message.channel_id);
        const obj = callback(closure_2[10]);
      }
      if (isReadableChannelIdResult) {
        if (callback6(message.message)) {
          self.upsertOne(message.guildId, message.message.channel_id, message.message, arg1);
        } else {
          self.updateOne(message.guildId, message.message.channel_id, message.message, arg1);
        }
      }
    }
  };
  items[4] = {
    key: "handleMessagePreviewsLoaded",
    value(messages) {
      let iter2;
      const self = this;
      const tmp = callback5(messages.messages);
      let iter = tmp();
      if (!iter.done) {
        do {
          let value = iter.value;
          let tmp2 = closure_0;
          let tmp3 = closure_2;
          let obj = closure_0(closure_2[10]);
          if (obj.isReadableChannelId(value.channel_id)) {
            let tmp4 = self;
            let tmp5 = value;
            let tmp6 = arg1;
            let insertStaleResult = self.insertStale(messages.guildId, value.channel_id, value, arg1);
          }
          iter2 = tmp();
          iter = iter2;
        } while (!iter2.done);
      }
    }
  };
  items[5] = {
    key: "handleLoadMessagesSuccess",
    value(channelId) {
      const self = this;
      const basicChannel = basicChannel.getBasicChannel(channelId.channelId);
      if (null != basicChannel) {
        if (obj.isReadableChannelId(channelId.channelId)) {
          if (!channelId.isAfter) {
            if (!channelId.isBefore) {
              if (!channelId.hasMoreAfter) {
                if (channelId.limit > 5) {
                  self.replaceChannel(basicChannel.guild_id, channelId.channelId, channelId.messages, arg1);
                }
              }
            }
          }
          self.upsertMany(basicChannel.guild_id, channelId.channelId, channelId.messages, arg1);
        }
        const obj = callback(closure_2[10]);
      }
    }
  };
  items[6] = {
    key: "handleMessageDelete",
    value(id) {
      const self = this;
      if (null != id.id) {
        self.deleteOne(id.guildId, id.channelId, id.id, arg1);
      }
    }
  };
  items[7] = {
    key: "handleMessageDeleteBulk",
    value(ids) {
      let done;
      const self = this;
      const tmp = callback5(ids.ids);
      let iter = tmp();
      if (!iter.done) {
        do {
          let tmp2 = self;
          let tmp3 = arg1;
          let deleteOneResult = self.deleteOne(ids.guildId, ids.channelId, iter.value, arg1);
          let iter2 = tmp();
          iter = iter2;
          done = iter2.done;
        } while (!done);
      }
    }
  };
  items[8] = {
    key: "handleChannelDelete",
    value(channel) {
      this.deleteChannel(channel.channel.guild_id, channel.channel.id, arg1);
    }
  };
  items[9] = {
    key: "handleGuildDelete",
    value(guild) {
      const self = this;
      if (!guild.guild.unavailable) {
        self.deleteGuild(guild.guild.id, arg1);
      }
    }
  };
  items[10] = {
    key: "resetInMemoryState",
    value() {

    }
  };
  items[11] = {
    key: "insertStale",
    value(arg0, arg1, arg2, arg3) {
      const obj = callback2(closure_2[9]);
      const result = closure_7.lastTimeConnectedChanged();
      const KvMessage = callback(closure_2[11]).KvMessage;
      const messagesTransactionResult = callback2(closure_2[9]).messagesTransaction(arg3);
      messagesTransactionResult.put(arg0, arg1, KvMessage.fromMessage(arg0, arg1, arg2, result), callback(closure_2[12]).ConflictOptions.Skip);
    }
  };
  items[12] = {
    key: "upsertOne",
    value(items, limit) {
      const messagesTransactionResult = callback2(closure_2[9]).messagesTransaction(arg3);
      const result = closure_7.lastTimeConnectedChanged();
      const KvMessage = callback(closure_2[11]).KvMessage;
      const obj = callback2(closure_2[9]);
      messagesTransactionResult.put(items, limit, KvMessage.fromMessage(items, limit, arg2, result), callback(closure_2[12]).ConflictOptions.Replace);
      messagesTransactionResult.trimChannel(items, limit, closure_9.saveLimit(limit));
    }
  };
  items[13] = {
    key: "upsertMany",
    value(items, limit) {
      let done;
      const messagesTransactionResult = callback2(closure_2[9]).messagesTransaction(arg3);
      const result = closure_7.lastTimeConnectedChanged();
      const tmp2 = callback5(arg2);
      let iter = tmp2();
      if (!iter.done) {
        do {
          let tmp3 = closure_0;
          let tmp4 = closure_2;
          let KvMessage = closure_0(closure_2[11]).KvMessage;
          let tmp5 = KvMessage;
          let tmp6 = items;
          let tmp7 = limit;
          let tmp8 = result;
          let putResult = messagesTransactionResult.put(items, limit, KvMessage.fromMessage(items, limit, iter.value, result));
          let iter2 = tmp2();
          iter = iter2;
          done = iter2.done;
        } while (!done);
      }
      messagesTransactionResult.trimChannel(items, limit, closure_9.saveLimit(limit));
    }
  };
  items[14] = {
    key: "replaceChannel",
    value(items, limit, arr) {
      let closure_0 = items;
      const callback2 = limit;
      const messagesTransactionResult = callback2(closure_2[9]).messagesTransaction(arg3);
      closure_2 = closure_7.lastTimeConnectedChanged();
      const saveLimitResult = closure_9.saveLimit(limit);
      let substr = arr;
      if (arr.length > saveLimitResult) {
        substr = arr.slice(arr.length - saveLimitResult);
      }
      messagesTransactionResult.replaceChannel(items, limit, substr.map((arg0) => {
        const KvMessage = arg0(closure_2[11]).KvMessage;
        return KvMessage.fromMessage(arg0, arg1, arg0, closure_2);
      }));
      messagesTransactionResult.trimChannel(items, limit, closure_9.saveLimit(limit));
    }
  };
  const obj13 = { key: "updateOne" };
  let closure_0 = callback(async (arg0, arg1, arg2, arg3) => {
    if (null != arg2.id) {
      let obj = callback2(closure_2[9]);
      const messagesResult = obj.messages(arg3.database);
      const tmp6 = yield messagesResult.get(arg0, arg1, arg2.id);
      const result = closure_7.lastTimeConnectedChanged();
      if (null != tmp6) {
        const KvMessage = callback(closure_2[11]).KvMessage;
        obj = {};
        const merged = Object.assign(tmp6.message);
        const merged1 = Object.assign(arg2);
        messagesResult.put(arg0, arg1, KvMessage.fromMessage(arg0, arg1, obj, result));
      }
    } else {
      closure_10.warn("updateOne: message.id is null; cannot update a message if we do not know its id.");
    }
  });
  obj13.value = function updateOne(guildId, channel_id, message, arg3) {
    return callback(...arguments);
  };
  items[15] = obj13;
  items[16] = {
    key: "deleteOne",
    value(arg0, arg1, arg2, arg3) {
      const obj = callback2(closure_2[9]);
      callback2(closure_2[9]).messagesTransaction(arg3).deleteMessage(arg0, arg1, arg2);
    }
  };
  items[17] = {
    key: "deleteChannel",
    value(arg0, arg1, arg2) {
      const obj = callback2(closure_2[9]);
      callback2(closure_2[9]).messagesTransaction(arg2).deleteChannel(arg0, arg1);
    }
  };
  items[18] = {
    key: "deleteGuild",
    value(arg0, arg1) {
      const obj = callback2(closure_2[9]);
      callback2(closure_2[9]).messagesTransaction(arg1).deleteGuild(arg0);
    }
  };
  return callback2(Messages, items);
}();
tmp5 = new tmp5();
const result = arg1(dependencyMap[13]).fileFinishedImporting("modules/app_database/modules/Messages.tsx");

export default tmp5;
export const ChannelHistory = tmp4;
export { isLikelyNotDelta };