// Module ID: 5208
// Function ID: 5209
// Name: CloudUpload
// Dependencies: [109, 5, 32, 4635, 1183, 4685, 1074, 3, 1270, 5209, 5217, 1090, 559, 5250, 12, 1461, 5219, 5252, 5253, 5238, 5254, 5255, 5259, 5260, 1230, 5218, 5210, 5261, 5262, 1896, 5347, 1240, 2]

// Module 5208 (CloudUpload)
import LoggerDefault from "Logger" /* 3 */;
import BackoffDefault from "Backoff" /* 559 */;
import DurationsDefault from "Durations" /* 1090 */;
import AnalyticsUtilsDefault from "AnalyticsUtils" /* 1240 */;
import HTTPUtils from "HTTPUtils" /* 1270 */;
import Upload2 from "Upload" /* 5209 */;
import InlineUploaderDefault from "InlineUploader" /* 5250 */;
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;
import _slicedToArray from "module_32" /* 32 */;
import DevSettingsStore from "DevSettingsStore" /* 4635 */;
import UnsyncedUserSettingsStore from "UnsyncedUserSettingsStore" /* 1183 */;
import NetworkStore from "NetworkStore" /* 4685 */;

const Upload = Upload2;

require = fn;
let closure_3 = ["Content-Range"];
const Constants = fn(1074);
({ AbortCodes: c10, AnalyticEvents: closure_11 } = Constants);
const logger = new LoggerDefault("CloudUpload.tsx");
const set = new Set([429]);
let ResumableUploadError;
class ResumableUploadError extends Error {
  constructor(arg0) {
    obj = fn;
    num = undefined;
    if (fn === undefined) {
      obj = {};
    }
    ({ cause, response } = obj);
    error = cause;
    tmp = ResumableUploadError;
    if (cause == null) {
      tmp3 = globalThis;
      str = undefined;
      if (response != null) {
        str = response.text;
      }
      if (str == null) {
        str = "Unknown error";
      }
      _HermesInternal = HermesInternal;
      str2 = "";
      tmp4 = new.target;
      tmp5 = new.target;
      error = new Error("" + str);
    }
    errorKind = ResumableUploadError.getErrorKind(error, response);
    if ("server_error" !== errorKind) {
      str3 = "client_error";
      if ("client_error" !== errorKind) {
        tmp7 = globalThis;
        _HermesInternal2 = HermesInternal;
        str4 = ":";
        str5 = "";
        combined = "" + global + ":" + errorKind;
      }
      tmp10 = new.target;
      tmp11 = ResumableUploadError;
      obj1 = { cause: null };
      obj1.cause = cause;
      tmp12 = new.target;
      tmp13 = new.target;
      tmp14 = combined;
      tmp15 = obj1;
      response1 = new response(combined, obj1, errorKind, ":status_", tmp9, str, num, concat);
      tmp17 = response1;
      str6 = "ResumableUploadError";
      response1.name = "ResumableUploadError";
      response1.phase = global;
      response1.kind = errorKind;
      response1.messageShort = combined;
      return response1;
    }
    num = undefined;
    if (response != null) {
      num = response.status;
    }
    if (num == null) {
      num = 0;
    }
    response = HermesInternal;
    concat = HermesInternal.concat;
    tmp9 = num;
    combined = concat(global, ":", errorKind, ":status_", num);
    return;
  }
}
ResumableUploadError["getErrorKind"] = function getErrorKind(error, response) {
  let num;
  if (response != null) {
    num = response.status;
  }
  if (num == null) {
    num = 0;
  }
  const hasItem = set.has(num);
  const formatted = error.message.toLowerCase();
  let hasItem1 = formatted.includes("network");
  if (!hasItem1) {
    const formatted1 = error.message.toLowerCase();
    hasItem1 = formatted1.includes("terminated");
  }
  if (!hasItem1) {
    const formatted2 = error.message.toLowerCase();
    hasItem1 = formatted2.includes("offline");
  }
  if (!hasItem1) {
    const formatted3 = error.message.toLowerCase();
    hasItem1 = formatted3.includes("changed");
  }
  if (num < 500) {
    let str9 = "client_error";
    if (!hasItem) {
      let str10 = "unknown";
      if (hasItem1) {
        str10 = "network_error";
      }
      str9 = str10;
    }
    let str8 = str9;
  } else {
    str8 = "server_error";
  }
  return str8;
};
ResumableUploadError["rejectionHandler"] = function rejectionHandler(status_check) {
  closure_0 = status_check;
  return (response) => {
    if (response instanceof HTTPUtils.HTTPResponseError) {
      const obj2 = { response };
      throw new ResumableUploadError(closure_0, obj2);
    } else {
      const _Error = Error;
      const obj = { cause: null };
      if (response instanceof Error) {
        obj.cause = response;
        throw new tmp2(tmp3, obj);
      } else {
        const _Error2 = Error;
        const _String = String;
        const error = new Error(String(response));
        obj.cause = error;
        throw new tmp2(tmp3, obj);
      }
    }
  };
};
ResumableUploadError.prototype["canRetry"] = function canRetry() {
  const self = this;
  let tmp = "server_error" === this.kind;
  if (!tmp) {
    tmp = "network_error" === self.kind;
  }
  if (!tmp) {
    tmp = "client_error" === self.kind;
  }
  return tmp;
};
const CloudUploadStatus = { NOT_STARTED: "NOT_STARTED", STARTED: "STARTED", UPLOADING: "UPLOADING", ERROR: "ERROR", COMPLETED: "COMPLETED", CANCELED: "CANCELED", REMOVED_FROM_MSG_DRAFT: "REMOVED_FROM_MSG_DRAFT" };
let closure_16 = function UploadAnalytics() {
  const merged = Object.assign({ timing: null, uploadResumptionCount: 0, uploadResumptionPosition: 0 });
  merged[0] = {};
  return merged;
}.prototype;
let CloudUpload;
class CloudUpload extends tmp5 {
  constructor(arg0, arg1, arg2, arg3) {
    obj = new CloudUpload(global, tmp4, tmp3, new.target, global, new.target, tmp2, CloudUpload, tmp);
    closure_0 = obj;
    obj.status = closure_15.NOT_STARTED;
    obj.loaded = 0;
    obj.reactNativeFilePrepped = false;
    if (typeof closure_16 === "function") {
      tmp6 = fn;
      merged = Object.assign({ timing: null, uploadResumptionCount: 0, uploadResumptionPosition: 0 });
      merged[0] = {};
      obj.uploadAnalytics = merged;
      obj.uploadAttempts = 0;
      obj._aborted = false;
      tmp8 = null;
      obj._originalMd5 = null;
      obj.createResumeAwareProgressFn = function createResumeAwareProgressFn(arg0) {
        closure_0 = arg0;
        return (loaded) => {
          const sum = loaded.loaded + closure_0;
          obj.emit("progress", sum, loaded.total + closure_0, sum - obj.loaded);
          obj.loaded = sum;
        };
      };
      obj.channelId = fn;
      file = global.file;
      num = undefined;
      if (file != null) {
        num = file.size;
      }
      if (num == null) {
        num = 0;
      }
      obj.preCompressionSize = num;
      file2 = global.file;
      num2 = undefined;
      if (file2 != null) {
        num2 = file2.size;
      }
      if (num2 == null) {
        num2 = 0;
      }
      tmp9 = importDefault;
      tmp10 = importAll;
      obj.currentSize = num2;
      obj.reactNativeFileIndex = importDefault;
      if (null != importAll) {
        obj.allowOptimization = importAll;
      }
      tmp11 = closure_0;
      tmp12 = closure_2;
      tmp13 = global.platform === closure_0(closure_2[9]).UploadPlatform.WEB && null != global.compressionMetadata;
      if (tmp13) {
        obj.mimeType = global.compressionMetadata.originalContentType;
        obj.preCompressionSize = global.compressionMetadata.preCompressionSize;
      }
      tmp14 = global.platform === tmp11(tmp12[9]).UploadPlatform.WEB && null != global.originalMd5;
      if (tmp14) {
        obj._originalMd5 = global.originalMd5;
      }
      result = obj.applyItemConversionAnalytics();
      tmp16 = globalThis;
      _AbortController = AbortController;
      tmp17 = new.target;
      tmp18 = new.target;
      abortController = new AbortController();
      tmp20 = abortController;
      obj._abortController = abortController;
      if (null == obj.origin) {
        tmp21 = new.target;
        tmp22 = new.target;
        defaultHttpClient = new tmp11(tmp12[10]).DefaultHttpClient();
        tmp24 = defaultHttpClient;
        obj._uploadHttpClient = defaultHttpClient;
        obj._libdiscoreEnabled = false;
        return obj;
      } else {
        if (typeof obj.origin === "string") {
          origin = obj.origin;
        } else {
          origin = tmp11(tmp12[9]).UploadOrigin[obj.origin];
        }
        obj.uploadAnalytics.origin = origin;
      }
    } else {
      str = "Trying to call a non-function";
      throw new TypeError("Trying to call a non-function");
    }
    return;
  }
  resetState() {
    self = this;
    this.status = closure_15.NOT_STARTED;
    this.uploadedFilename = undefined;
    this.responseUrl = undefined;
    this.responseUrlSetAt = undefined;
    this.error = undefined;
    this.startTime = undefined;
    if (typeof closure_16 === "function") {
      merged = Object.assign({ timing: null, uploadResumptionCount: 0, uploadResumptionPosition: 0 });
      merged[0] = {};
      self.uploadAnalytics = merged;
      result = self.applyItemConversionAnalytics();
      num = 0;
      self.uploadAttempts = 0;
      flag = false;
      self._aborted = false;
      tmp3 = globalThis;
      _AbortController = AbortController;
      tmp4 = new.target;
      tmp5 = new.target;
      abortController = new AbortController();
      tmp7 = abortController;
      self._abortController = abortController;
      tmp8 = closure_20;
      return super.resetState();
    } else {
      str = "Trying to call a non-function";
      throw new TypeError("Trying to call a non-function");
    }
  }
}
const prototype = CloudUpload.prototype;
CloudUpload["fromJson"] = function fromJson(item) {
  let tmp = new CloudUpload(item.item, item.channelId, item.reactNativeFileIndex);
  closure_0 = tmp;
  const entries = Object.entries(item);
  item = entries.forEach((item) => {
    const tmp = _slicedToArray(item, 2);
    const first = tmp[0];
    if (!first.startsWith("_")) {
      closure_0[first] = tmp[1];
    }
  });
  if (tmp.status !== obj.COMPLETED) {
    tmp.status = obj.NOT_STARTED;
  }
  return tmp;
};
prototype["parseRangeHeader"] = function parseRangeHeader(str) {
  const match = str.match(/^bytes=(\d+)-(\d+)(?:\/\d+)?$/);
  let tmp2 = null;
  if (null != match) {
    const _parseInt = parseInt;
    const items = [parseInt(match[1], 10), ];
    const _parseInt2 = parseInt;
    items[1] = parseInt(match[2], 10);
    tmp2 = items;
  }
  return tmp2;
};
prototype["retryOpts"] = function retryOpts() {
  if (this.item.platform === Upload2.UploadPlatform.REACT_NATIVE) {
    const obj2 = { timeout: DurationsDefault.Millis.HOUR, backoff: null, retries: 12 };
    const result = 0.5 * DurationsDefault.Millis.SECOND;
    const tmp82 = new BackoffDefault(result, 30 * DurationsDefault.Millis.MINUTE);
    obj2.backoff = tmp82;
    let obj = obj2;
  } else {
    obj = { timeout: DurationsDefault.Millis.HOUR, retries: 12, backoff: null };
    const tmp5 = new BackoffDefault();
    obj.backoff = tmp5;
  }
  return obj;
};
prototype["createAttachmentUrlRetryOpts"] = function createAttachmentUrlRetryOpts() {
  const self = this;
  if (this.item.platform === Upload2.UploadPlatform.REACT_NATIVE) {
    const obj = { timeout: null, backoff: null, retries: 8 };
    const obj2 = { response: 30 * DurationsDefault.Millis.SECOND, deadline: 30 * DurationsDefault.Millis.MINUTE };
    obj.timeout = obj2;
    const result = 0.5 * DurationsDefault.Millis.SECOND;
    const tmp42 = new BackoffDefault(result, 60 * DurationsDefault.Millis.SECOND);
    obj.backoff = tmp42;
    let retryOptsResult = obj;
  } else {
    retryOptsResult = self.retryOpts();
  }
  return retryOptsResult;
};
prototype["buildOriginalMd5Headers"] = function buildOriginalMd5Headers() {
  return InlineUploaderDefault.buildHeadersForMd5(this._originalMd5);
};
prototype["supportsResume"] = function supportsResume() {
  let _libdiscoreEnabled = this._libdiscoreEnabled;
  if (!_libdiscoreEnabled) {
    _libdiscoreEnabled = this.item.platform !== Upload2.UploadPlatform.REACT_NATIVE;
  }
  return _libdiscoreEnabled;
};
prototype["uploadFileToCloud"] = function uploadFileToCloud() {
  const self = this;
  return (async () => {
    if (null == self.responseUrl) {
      const _Error = Error;
      const error = new Error("_uploadFileToCloud - responseUrl is not set");
      throw error;
    }
    const _HermesInternal3 = HermesInternal;
    const combined = "Uploading " + obj8.id;
    if (obj8.item.platform === v3(dependencyMap[9]).UploadPlatform.REACT_NATIVE) {
      const _HermesInternal2 = HermesInternal;
      let combined1 = "filename=" + obj8.item.filename + ", uri=" + obj8.item.uri;
    } else {
      const _HermesInternal = HermesInternal;
      combined1 = "filename=" + obj8.item.file.name;
    }
    logger.log(combined, combined1);
    if (obj8.item.platform === v3(dependencyMap[9]).UploadPlatform.REACT_NATIVE) {
      const obj4 = { type: obj8.item.mimeType, uri: obj8.item.uri, name: obj8.item.filename };
      let str6 = "application/octet-stream";
      if (null != obj4.type) {
        str6 = "application/octet-stream";
        if ("application/json" !== obj4.type) {
          str6 = obj4.type;
        }
      }
      let str4 = str6;
      let file = obj4;
    } else {
      file = obj8.item.file;
      str4 = "application/octet-stream";
    }
    if (tmp25Result.canUploadNatively(obj8.item)) {
      const libdiscoreHttpClient = new tmp25(tmp26[10]).LibdiscoreHttpClient();
      obj8._uploadHttpClient = libdiscoreHttpClient;
      obj8._libdiscoreEnabled = true;
      logger.log("Using libdiscore client for file upload");
    }
    await obj8.uploadFileWithResumption(obj8.responseUrl, file, str4);
    return arg1;
  })();
};
prototype["getResumePosition"] = function getResumePosition(responseUrl) {
  closure_0 = responseUrl;
  const self = this;
  return (async () => {
    const obj4 = { url, headers: { "Content-Range": "bytes */*" }, rejectWithError: true, retries: 0, timeout: { deadline: 30 * v1(1090).Millis.SECOND }, signal: self._abortController.signal };
    const _uploadHttpClient = self._uploadHttpClient;
    _uploadHttpClient.doUpload(obj4);
    await _uploadHttpClient.doUpload(obj4).then((status) => {
      if (200 !== status.status) {
        if (201 !== status.status) {
          let currentSize = closure_2_14.rejectionHandler("status_check")(status);
        }
        return currentSize;
      }
      currentSize = v1.currentSize;
    }).catch((error) => {
      if (error instanceof c0(1270).HTTPResponseError) {
        if (308 === error.status) {
          let str = error.headers.range;
          if (str == null) {
            str = "";
          }
          const parseRangeHeaderResult = v1.parseRangeHeader(str);
          let num2 = 0;
          if (null != parseRangeHeaderResult) {
            num2 = parseRangeHeaderResult[1] + 1;
          }
          return num2;
        }
      }
      return closure_2_14.rejectionHandler("status_check")(error);
    });
    return arg1;
  })();
};
prototype["startOrResumeUpload"] = function startOrResumeUpload(arg0, arg1) {
  closure_0 = arg0;
  const self = this;
  return (async (arg0, value) => {
    if (v3 === 2) {
      v3 = 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 {
        v3 = 2;
        if (0 === c3) {
          if (arg0 === 1) {
            v3 = 3;
            throw value;
          } else if (arg0 === 2) {
            v3 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            let obj7;
            closure_129_0 = undefined;
            let _catch = self;
            let obj5 = globalThis;
            const _HermesInternal = HermesInternal;
            logger.log("Attempting to upload attachment with resumeFrom: " + num + " and attempts: " + self.uploadAttempts);
            if (num > 0) {
              const uploadAnalytics = _catch.uploadAnalytics;
              uploadAnalytics.uploadResumptionCount = uploadAnalytics.uploadResumptionCount + 1;
              const headers = config.headers;
              config = headers;
              if (headers == null) {
                config = {};
              }
              const obj4 = {};
              const merged = Object.assign(config);
              obj4["Content-Range"] = "bytes " + tmp37 + "-" + _catch.currentSize - 1 + "/" + _catch.currentSize;
              config.headers = obj4;
              let tmp18 = tmp19;
            } else {
              tmp18 = config;
              if (null != config.headers) {
                const headers2 = tmp16.headers;
                const prop = headers2["Content-Range"];
                tmp16.headers = v3(headers2, c3);
                tmp18 = tmp16;
              }
            }
            obj5 = tmp2(tmp3[14]);
            tmp18.onRequestProgress = obj5.throttle(_catch.createResumeAwareProgressFn(num), 50);
            const _uploadHttpClient = _catch._uploadHttpClient;
            const obj6 = { fileByteRange: null };
            obj7 = { start: num };
            obj6.fileByteRange = obj7;
            _catch = _uploadHttpClient.doUpload(tmp18, obj6).catch;
            _catch(ResumableUploadError.rejectionHandler("upload"));
            c3 = 1;
            v3 = 1;
            const doUploadResult = _uploadHttpClient.doUpload(tmp18, obj6);
          }
        } else if (arg0 === 1) {
          v3 = 3;
          throw value;
        } else if (arg0 === 2) {
          v3 = 3;
          const obj8 = { value, done: true };
          return obj8;
        } else {
          closure_129_0 = value;
          if (200 !== closure_129_0.status) {
            if (201 !== closure_129_0.status) {
              const obj9 = { response: closure_129_0 };
              throw new ResumableUploadError("upload", obj9);
            }
          }
          v3 = 3;
          const obj = { value: closure_129_0, done: true };
          return obj;
        }
      } catch (tmp29) {
        v3 = tmp;
        throw tmp29;
      }
    }
  })();
};
prototype["uploadFileWithResumption"] = function uploadFileWithResumption(responseUrl, file, arg2) {
  closure_0 = responseUrl;
  closure_1 = file;
  closure_2 = arg2;
  const self = this;
  return (async (arg0, url) => {
    if (c9 === 2) {
      c9 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp7 === 3) {
      if (arg0 === 1) {
        throw url;
      } else if (arg0 === 2) {
        let obj2 = { value: url, done: true };
        return obj2;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c9 = 2;
        if (0 === c8) {
          if (arg0 === 1) {
            c9 = 3;
            throw url;
          } else if (arg0 === 2) {
            c9 = 3;
            let obj3 = { value: url, done: true };
            return obj3;
          } else {
            closure_4 = tmp5;
            closure_132_0 = undefined;
            closure_132_1 = undefined;
            closure_132_2 = undefined;
            closure_132_3 = undefined;
            closure_132_4 = undefined;
            closure_132_5 = undefined;
            const retryOptsResult = self.retryOpts();
            ({ backoff: closure_132_1, retries } = retryOptsResult);
            closure_132_2 = retries;
            const request = { url, body, headers: null, signal: null, onRequestProgress: null, retries: 0, rejectWithError: true, timeout: null };
            let obj4 = { "Content-Type": next };
            request.headers = obj4;
            request.signal = self._abortController.signal;
            request.onRequestProgress = iter4(next[14]).throttle(self.createResumeAwareProgressFn(0), 50);
            request.timeout = retryOptsResult.timeout;
            closure_132_3 = request;
            closure_132_4 = 0;
            closure_132_5 = async function _loop(arg0, value) {
              if (c6 === 2) {
                c6 = 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) {
                  const obj2 = { value, done: true };
                  return obj2;
                } else {
                  return { value: "HermesInternal", done: null };
                }
              } else {
                try {
                  c6 = 2;
                  if (0 === c5) {
                    if (arg0 === 1) {
                      c6 = 3;
                      throw value;
                    } else if (arg0 === 2) {
                      c6 = 3;
                      const obj3 = { value, done: true };
                      return obj3;
                    } else {
                      closure_2 = tmp3;
                      closure_1 = tmp5;
                      responseUrl = undefined;
                      closure_129_1 = undefined;
                      closure_129_2 = undefined;
                      c3.uploadAttempts = c3.uploadAttempts + 1;
                      c3.uploadAnalytics.numUploadAttempts = c3.uploadAttempts;
                      c3 = 1;
                      responseUrl = c3.responseUrl;
                      c5 = 2;
                      c6 = 1;
                      const obj4 = { value: c3.ensureFreshResponseUrl(), done: false };
                      return obj4;
                    }
                  } else if (1 === tmp8) {
                    c3 = 0;
                    closure_129_3 = closure_4;
                    if (closure_129_3 instanceof closure_2_14) {
                      if (closure_129_3.canRetry()) {
                        const _HermesInternal2 = HermesInternal;
                        logger.warn("Error uploading " + c3.id + ": " + closure_129_3.message + ", attempting resumption");
                        c3.uploadAnalytics.uploadResumptionReason = closure_129_3.messageShort;
                        c5 = 5;
                        c6 = 1;
                        const obj5 = { value: body(next[15]).awaitOnline(), done: false };
                        return obj5;
                      }
                    }
                    const _HermesInternal = HermesInternal;
                    logger.warn("Unrecoverable error uploading " + c3.id + ": " + closure_129_3.message);
                    throw closure_129_3;
                  } else {
                    if (2 === tmp8) {
                      if (arg0 === 1) {
                        c6 = 3;
                        throw value;
                      } else if (arg0 === 2) {
                        c3 = 0;
                        c6 = 3;
                        const obj6 = { value, done: true };
                        return obj6;
                      } else {
                        closure_130_3.url = c3.responseUrl;
                        if (responseUrl !== c3.responseUrl) {
                          closure_130_4 = 0;
                          c3.loaded = 0;
                        } else if (c3.uploadAttempts > 1) {
                          c5 = 4;
                          c6 = 1;
                          const obj7 = {
                            value: c3.trackTime("resumptionCheckTimeMs", tmp3(async () => {
                                          await resumePosition.getResumePosition(resumePosition.responseUrl);
                                          return arg1;
                                        })),
                            done: false
                          };
                          return obj7;
                        }
                        value = {};
                        c3.startOrResumeUpload(closure_130_3, closure_130_4);
                        c5 = 3;
                        c6 = 1;
                      }
                    } else if (3 === tmp8) {
                      if (arg0 === 1) {
                        c6 = 3;
                        throw value;
                      } else if (arg0 === 2) {
                        c3 = 0;
                        c6 = 3;
                        const obj8 = { value, done: true };
                        return obj8;
                      } else {
                        value.v = value;
                        c3 = 0;
                        c6 = 3;
                        const obj10 = { value, done: true };
                        return obj10;
                      }
                    } else if (4 === tmp8) {
                      if (arg0 === 1) {
                        c6 = 3;
                        throw value;
                      } else if (arg0 !== 2) {
                        closure_129_1 = value;
                        c3.uploadAnalytics.uploadResumptionPosition = closure_129_1;
                        let num7 = 0;
                        if (c3.supportsResume()) {
                          num7 = closure_129_1;
                        }
                        closure_130_4 = num7;
                        c3.loaded = closure_130_4;
                      }
                    } else if (5 === tmp8) {
                      if (arg0 === 1) {
                        c6 = 3;
                        throw value;
                      } else if (arg0 === 2) {
                        c6 = 3;
                        const obj11 = { value, done: true };
                        return obj11;
                      } else {
                        closure_129_2 = closure_130_1.fail();
                        const _HermesInternal3 = HermesInternal;
                        logger.log("Waiting " + closure_129_2 + "ms before attachment upload attempt " + c3.uploadAttempts + 1);
                        const promise = new Promise((arg0) => setTimeout(arg0, closure_1_2));
                        c5 = 6;
                        c6 = 1;
                        const obj12 = { value: promise, done: false };
                        return obj12;
                      }
                    } else if (arg0 === 1) {
                      c6 = 3;
                      throw value;
                    } else if (arg0 === 2) {
                      c6 = 3;
                      const obj = { value, done: true };
                      return obj;
                    } else {
                      c6 = 3;
                      return { value: "HermesInternal", done: null };
                    }
                    c3 = 0;
                    c6 = 3;
                    const obj13 = { value, done: true };
                    return obj13;
                  }
                } catch (tmp59) {
                  closure_4 = tmp59;
                  if (tmp4 === c3) {
                    c6 = tmp2;
                    throw tmp59;
                  } else {
                    c5 = tmp;
                  }
                }
              }
            };
            if (self.uploadAttempts <= retries) {
              if (!self._aborted) {
                const iter3 = closure_132_5()[tmp59.iterator]();
                HermesBuiltin.ensureObject("iterator is not an object");
                next = iter3.next;
                url = undefined;
                const tmp29 = closure_132_5();
              }
            }
            const _Error = Error;
            let _HermesInternal = HermesInternal;
            const error = new Error("Upload failed after " + closure_133_3.uploadAttempts + " attempts");
            throw error;
          }
        } else {
          if (1 === tmp8) {
            c6 = 1;
            if (arg0 === 1) {
              c9 = 3;
              throw url;
            } else if (arg0 === 2) {
              c6 = 0;
              const method = HermesBuiltin.getMethod("return");
              if (method === undefined) {
                c9 = 3;
                let obj5 = { value: url, done: true };
                return obj5;
              } else {
                const iter2 = method(url);
                HermesBuiltin.ensureObject("iterator.return() did not return an object");
                if (iter2.done) {
                  c9 = 3;
                  let obj = { value: iter2.value, done: true };
                  return obj;
                } else {
                  c8 = 1;
                  c9 = 1;
                  return iter2;
                }
              }
            } else {
              c6 = 0;
              const tmp20 = url;
            }
          } else {
            c6 = 0;
            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) {
                iter4 = iter;
              } else {
                c8 = 1;
                c9 = 1;
                return iter;
              }
            }
            tmp10 = closure_7;
          }
          value = iter4.value;
          closure_132_0 = value;
          if (value) {
            c9 = 3;
            let obj6 = { value: closure_132_0.v, done: true };
            return obj6;
          }
        }
        iter4 = next(tmp20);
        HermesBuiltin.ensureObject("iterator.next() did not return an object");
        if (!iter4.done) {
          c8 = 1;
          c9 = 1;
          return iter4;
        }
      } catch (tmp51) {
        closure_7 = tmp51;
        if (tmp4 === c6) {
          c9 = tmp2;
          throw tmp51;
        } else {
          c8 = tmp;
        }
      }
    }
  })();
};
prototype["getSize"] = function getSize() {
  const self = this;
  return (async () => {
    const getFileSize = value(c2[16]).getFileSize;
    if (getFileSize != null) {
      const fileSize = getFileSize(self.item.uri);
    }
    value = await fileSize;
    if (arg1 == null) {
      value = 0;
    }
    return value;
  })();
};
prototype["trackTime"] = function trackTime(compressTimeMs, arg1) {
  closure_0 = compressTimeMs;
  closure_1 = arg1;
  const self = this;
  return (async (arg0, value) => {
    if (c5 === 2) {
      c5 = 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) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c5 = 2;
        if (0 === c4) {
          if (arg0 === 1) {
            c5 = 3;
            throw value;
          } else if (arg0 === 2) {
            c5 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_0 = tmp5;
            closure_128_0 = undefined;
            const _performance4 = performance;
            closure_128_0 = performance.now();
            c3 = 1;
            c4 = 2;
            c5 = 1;
            const obj4 = { value: tmp3(), done: false };
            return obj4;
          }
        } else if (1 === tmp8) {
          c3 = 0;
          const _performance3 = performance;
          closure_129_2.uploadAnalytics.timing[closure_129_0] = performance.now() - closure_128_0;
          throw closure_2;
        } else if (arg0 === 1) {
          c5 = 3;
          throw value;
        } else if (arg0 === 2) {
          c3 = 0;
          const _performance2 = performance;
          closure_129_2.uploadAnalytics.timing[closure_129_0] = performance.now() - closure_128_0;
          c5 = 3;
          const obj5 = { value, done: true };
          return obj5;
        } else {
          c3 = 0;
          const _performance = performance;
          closure_129_2.uploadAnalytics.timing[closure_129_0] = performance.now() - closure_128_0;
          c5 = 3;
          const obj = { value, done: true };
          return obj;
        }
      } catch (tmp27) {
        closure_2 = tmp27;
        if (tmp4 === c3) {
          c5 = tmp2;
          throw tmp27;
        } else {
          c4 = tmp;
        }
      }
    }
  })();
};
prototype["upload"] = function upload() {
  const self = this;
  return (async (arg0, value) => {
    if (c9 === 2) {
      c9 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp8 === 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;
        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_4 = tmp9;
            closure_132_0 = undefined;
            let config;
            let file;
            closure_132_3 = undefined;
            closure_132_4 = undefined;
            closure_132_5 = undefined;
            let uploadTarget;
            let kestrelConfig;
            let effectiveKestrelLimit;
            closure_132_9 = undefined;
            closure_132_10 = undefined;
            if (self.status !== constants2.COMPLETED) {
              self.setStatus(constants2.STARTED);
              const _performance = performance;
              self.startTime = performance.now();
              self.trackUploadStart();
              if (false === self.reactNativeFilePrepped) {
                c8 = 1;
                c9 = 1;
                const obj5 = { value: self.reactNativeCompressAndExtractData(), done: false };
                return obj5;
              }
            }
            c9 = 3;
            c6 = 0;
            c9 = 3;
            const obj = { value, done: true };
            return obj;
          }
        } else {
          if (1 === tmp9) {
            if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c9 = 3;
              const obj8 = { value, done: true };
              return obj8;
            }
          } else {
            if (2 === tmp9) {
              if (arg0 === 1) {
                c9 = 3;
                throw value;
              } else if (arg0 === 2) {
                c9 = 3;
                const obj9 = { value, done: true };
                return obj9;
              } else {
                closure_132_3 = value;
                if (null != closure_132_3) {
                  closure_132_0 = true;
                  if (null != closure_132_3.convertedFile) {
                    let tmp130 = null == closure_133_0._originalMd5;
                    if (tmp130) {
                      tmp130 = null != file;
                    }
                    if (tmp130) {
                      closure_3 = closure_133_0;
                      const obj14 = status(5238);
                      c8 = 3;
                      c9 = 1;
                      const obj10 = { value: status(5238).fromBlob(file).catch(() => null), done: false };
                      return obj10;
                    }
                  }
                  const result = closure_133_0.applyConversionAnalytics(closure_132_3.analytics);
                }
              }
            } else {
              if (3 === tmp9) {
                if (arg0 === 1) {
                  c9 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c9 = 3;
                  const obj11 = { value, done: true };
                  return obj11;
                } else {
                  closure_3._originalMd5 = value;
                }
              } else if (4 === tmp9) {
                if (arg0 === 1) {
                  c9 = 3;
                  throw value;
                } else if (arg0 !== 2) {
                  closure_132_4 = value;
                  if (null != closure_132_4) {
                    if (null != closure_132_4.convertedFile) {
                      closure_133_0.item.file = closure_132_4.convertedFile;
                      closure_133_0.currentSize = closure_132_4.convertedFile.size;
                    }
                    if (null != closure_132_4.convertedMimeType) {
                      closure_133_0.uploadAnalytics.convertedMimeType = closure_132_4.convertedMimeType;
                    }
                    if (null != closure_132_4.hashTimeMs) {
                      closure_133_0.uploadAnalytics.timing.hashTimeMs = closure_132_4.hashTimeMs;
                    }
                    if (null != closure_132_4.conversionFailureReason) {
                      closure_133_0.uploadAnalytics.conversionFailureReason = closure_132_4.conversionFailureReason;
                    }
                    closure_133_0.uploadAnalytics.timing.compressTimeMs = closure_132_4.compressTimeMs;
                  }
                  const uploadPayload = v0(5254).default.getUploadPayload(closure_133_0);
                  c8 = 5;
                  c9 = 1;
                  const _default = v0(5254).default;
                }
              } else if (5 === tmp9) {
                if (arg0 === 1) {
                  c9 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c9 = 3;
                  const obj12 = { value, done: true };
                  return obj12;
                } else {
                  closure_132_5 = value;
                  uploadTarget = v0(5255).getUploadTarget(closure_133_0.item.target);
                  if (null != closure_132_5.filename) {
                    if ("" !== closure_132_5.filename) {
                      const currentSize2 = closure_133_0.currentSize;
                      if (0 !== closure_133_0.currentSize) {
                        kestrelConfig = v0(5260).getKestrelConfig({ location: "CloudUpload.upload.postCompressionCheck" });
                        const obj6 = v0(5260);
                        effectiveKestrelLimit = v0(5260).getEffectiveKestrelLimit(kestrelConfig, uploadTarget.getMaxFileSize(closure_133_0.channelId));
                        const currentSize = closure_133_0.currentSize;
                        v0 = currentSize;
                        if (currentSize == null) {
                          v0 = 0;
                        }
                        if (v0 > effectiveKestrelLimit) {
                          closure_133_0.handleError(constants.ENTITY_TOO_LARGE);
                        } else {
                          if (tmp213.get("upload_fail_50")) {
                            const _Math = Math;
                            if (Math.random() < 0.5) {
                              const _setTimeout = setTimeout;
                              const timerId = setTimeout(() => {
                                v0.handleError(500);
                              }, 1000);
                            }
                          }
                          c6 = 1;
                          const _HermesInternal3 = HermesInternal;
                          logger.log("Requesting upload url for " + closure_133_0.id);
                          c8 = 8;
                          c9 = 1;
                          const obj15 = {
                            value: closure_133_0.trackTime("getUploadUrlTimeMs", tmp3(async () => {
                                                    createAttachmentURL = createAttachmentURL.getCreateAttachmentURL(c0.channelId);
                                                    const HTTP = v0(dependencyMap[8]).HTTP;
                                                    const request = { url: createAttachmentURL, body: null, headers: c0.buildOriginalMd5Headers() };
                                                    const obj4 = { files: null };
                                                    const items = [closure_2_5];
                                                    obj4.files = items;
                                                    request.body = obj4;
                                                    const merged = Object.assign(c0.createAttachmentUrlRetryOpts());
                                                    request.rejectWithError = false;
                                                    await HTTP.post(request);
                                                    return arg1;
                                                  })),
                            done: false
                          };
                          return obj15;
                        }
                        const obj7 = v0(5260);
                      } else {
                        closure_133_0.handleError(constants.ENTITY_EMPTY);
                      }
                    }
                  }
                  const _JSON2 = JSON;
                  logger.error("File does not have a filename.", JSON.stringify(closure_132_5));
                  closure_133_0.handleError(constants.INVALID_FILE_ASSET);
                  c9 = 3;
                  const obj16 = { value: undefined, done: true };
                  return obj16;
                }
              } else if (6 === tmp9) {
                c6 = 0;
                closure_132_11 = tmp213;
                let code;
                if (closure_132_11 != null) {
                  const body = closure_132_11.body;
                  if (body != null) {
                    code = body.code;
                  }
                }
                status = code;
                if (code == null) {
                  status = closure_132_11.status;
                }
                closure_132_10 = status;
                if (closure_132_10 !== constants.ENTITY_TOO_LARGE) {
                  dependencyMap = closure_132_10;
                  if (closure_132_10 == null) {
                    const _JSON = JSON;
                    dependencyMap = JSON.stringify(closure_132_11.body);
                  }
                  const _HermesInternal2 = HermesInternal;
                  logger.error("Requesting upload url failed with code " + dependencyMap + " for " + closure_133_0.id);
                  status(1230).captureException(closure_132_11);
                  let obj4 = status(1230);
                }
                closure_133_0.handleError(closure_132_10);
                c9 = 3;
                const obj17 = { value: undefined, done: true };
                return obj17;
              } else if (7 === tmp9) {
                c6 = 0;
                closure_132_12 = tmp213;
                if (closure_133_0.isCancelled()) {
                  closure_133_0.handleComplete(closure_132_12);
                } else {
                  const _HermesInternal = HermesInternal;
                  logger.info("Error: status " + closure_132_12.status + " for " + closure_133_0.id);
                  closure_133_0.handleError(closure_132_12);
                }
              } else if (8 === tmp9) {
                if (arg0 === 1) {
                  c9 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c6 = 0;
                  c9 = 3;
                  const obj19 = { value, done: true };
                  return obj19;
                } else {
                  closure_132_9 = value;
                  closure_133_0.setResponseUrl(closure_132_9.body.attachments[0].upload_url);
                  closure_133_0.setUploadedFilename(closure_132_9.body.attachments[0].upload_filename);
                  c6 = 2;
                  c8 = 9;
                  c9 = 1;
                  const obj20 = {
                    value: closure_133_0.trackTime("uploadTimeMs", tmp3(async () => {
                                    await c0.uploadFileToCloud();
                                    return arg1;
                                  })),
                    done: false
                  };
                  return obj20;
                }
              } else if (arg0 === 1) {
                c9 = 3;
                throw value;
              } else if (arg0 !== 2) {
                closure_133_0.trackUploadFinished(constants2.COMPLETED);
                closure_133_0.handleComplete(closure_133_0.id);
                c6 = 0;
              }
              c9 = 3;
              const obj21 = { value, done: true };
              return obj21;
            }
            closure_133_0.item.file = closure_132_3.convertedFile;
            closure_133_0.currentSize = closure_132_3.convertedFile.size;
            closure_133_0.setFilename(closure_132_3.convertedFile.name);
            let tmp141 = null == file;
            if (!tmp141) {
              let tmp144 = null != closure_133_0.mimeType;
              if (tmp144) {
                tmp144 = "" !== closure_133_0.mimeType;
              }
              tmp141 = tmp144;
            }
            if (!tmp141) {
              closure_133_0.mimeType = v0(5252).heicMimeType(file);
              const obj13 = v0(5252);
            }
          }
          if (closure_133_0.isCancelled()) {
            obj18.handleComplete(closure_133_0.id);
          } else if (obj18.allowOptimization) {
            if (closure_133_0.item.platform === v0(5209).UploadPlatform.WEB) {
              if (!closure_132_0) {
                if (true !== closure_133_0.item.imageConversionEvaluated) {
                  c8 = 4;
                  c9 = 1;
                  const obj22 = { value: CloudUpload.tryConvertToWebP(closure_133_0.item.file, () => v0._aborted, closure_133_0.id), done: false };
                  return obj22;
                }
              }
            }
          }
        }
        if (closure_133_0.isCancelled()) {
          closure_133_0.handleComplete(closure_133_0.id);
        } else {
          closure_132_0 = false;
          if (closure_133_0.allowOptimization) {
            if (closure_133_0.item.platform === v0(5209).UploadPlatform.WEB) {
              if (true !== closure_133_0.item.imageConversionEvaluated) {
                if (null != closure_133_0.item.file) {
                  if (obj25.isHeicFile(closure_133_0.item.file)) {
                    const HeicUploadConversionExperiment = v0(5253).HeicUploadConversionExperiment;
                    config = HeicUploadConversionExperiment.getConfig({ location: "CloudUpload.tryConvertHeicToJpeg" });
                    if (config.enabled) {
                      file = closure_133_0.item.file;
                      c8 = 2;
                      c9 = 1;
                      const obj23 = { value: CloudUpload.tryConvertHeicToJpeg(closure_133_0.item.file, () => v0._aborted, closure_133_0.id, config.quality, config.maxFileSizeBytes), done: false };
                      return obj23;
                    }
                  }
                  obj25 = v0(5252);
                }
              }
            }
          }
        }
      } catch (tmp213) {
        if (tmp4 === c6) {
          c9 = tmp2;
          throw tmp213;
        } else if (tmp === tmp215) {
          c8 = tmp6;
        } else {
          c8 = tmp5;
        }
      }
    }
  })();
};
prototype["reactNativeCompressAndExtractData"] = function reactNativeCompressAndExtractData() {
  const self = this;
  return (async (arg0, value) => {
    if (c4 === 2) {
      c4 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp4 === 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 {
        c4 = 2;
        if (0 === c3) {
          if (arg0 === 1) {
            c4 = 3;
            throw value;
          } else if (arg0 === 2) {
            c4 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            dependencyMap = 0;
            closure_1 = tmp2;
            closure_129_0 = undefined;
            let uri;
            let name;
            closure_129_3 = undefined;
            closure_129_4 = undefined;
            closure_129_5 = undefined;
            closure_129_6 = undefined;
            if (obj17.getUploadTarget(self.item.target).shouldReactNativeCompressUploads) {
              if (true === tmp194.reactNativeFilePrepped) {
                self.uploadAnalytics.fileAlreadyPrepped = true;
                const _HermesInternal6 = HermesInternal;
                logger.log("reactNativeCompressAndExtractData() file already prepped - " + self.id);
                c4 = 3;
                const obj5 = { value: self, done: true };
                return obj5;
              } else {
                const _HermesInternal5 = HermesInternal;
                logger.log("Starting compression/conversion for " + self.id);
                c3 = 1;
                c4 = 1;
                const obj6 = {
                  value: self.trackTime("compressTimeMs", asyncGeneratorStep(async () => {
                                reactNativeFileIndex = reactNativeFileIndex.reactNativeFileIndex;
                                if (reactNativeFileIndex == null) {
                                  reactNativeFileIndex = 0;
                                }
                                await size(dependencyMap[25]).getAttachmentFile(reactNativeFileIndex, reactNativeFileIndex);
                                return arg1;
                              })),
                  done: false
                };
                return obj6;
              }
            } else {
              tmp194.uploadAnalytics.compressAndExtractDisabled = true;
              logger.log("reactNativeCompressAndExtractData() disabled by upload target");
              c4 = 3;
              const obj7 = { value: self, done: true };
              return obj7;
            }
            obj17 = size(5255);
          }
        } else {
          if (1 === tmp5) {
            if (arg0 === 1) {
              c4 = 3;
              throw value;
            } else if (arg0 === 2) {
              c4 = 3;
              const obj8 = { value, done: true };
              return obj8;
            } else {
              closure_129_0 = value;
              if (null != closure_129_0) {
                if (null != closure_129_0.file) {
                  uri = closure_129_0.uri;
                  name = closure_129_0.file.name;
                  if (obj14.isResolvedUpload(closure_129_0.file)) {
                    closure_130_0.uploadAnalytics.imageCompressionQuality = closure_129_0.file.imageCompressionQuality;
                    closure_130_0.uploadAnalytics.videoCompressionQuality = closure_129_0.file.videoCompressionQuality;
                    closure_130_0.uploadAnalytics.imageEncoderType = closure_129_0.file.imageEncoderType;
                    if (closure_129_0.file.isImage) {
                      closure_130_0.uploadAnalytics.sourceMediaWidth = closure_129_0.file.sourceWidth;
                      closure_130_0.uploadAnalytics.sourceMediaHeight = closure_129_0.file.sourceHeight;
                      closure_130_0.uploadAnalytics.uploadedImageWidth = closure_129_0.file.uploadedImageWidth;
                      closure_130_0.uploadAnalytics.uploadedImageHeight = closure_129_0.file.uploadedImageHeight;
                    }
                    if (undefined !== closure_129_0.file.videoMetadata) {
                      closure_130_0.uploadAnalytics.sourceMediaWidth = closure_129_0.file.videoMetadata.width;
                      closure_130_0.uploadAnalytics.sourceMediaHeight = closure_129_0.file.videoMetadata.height;
                      closure_130_0.uploadAnalytics.sourceMediaFormat = closure_129_0.file.videoMetadata.format;
                      closure_130_0.uploadAnalytics.sourceVideoBitrate = closure_129_0.file.videoMetadata.bitRate;
                      closure_130_0.uploadAnalytics.sourceVideoFramerate = closure_129_0.file.videoMetadata.frameRate;
                      closure_130_0.uploadAnalytics.videoDurationMs = closure_129_0.file.videoMetadata.durationMs;
                      closure_130_0.uploadAnalytics.sourceVideoProfile = closure_129_0.file.videoMetadata.sourceProfile;
                      closure_130_0.uploadAnalytics.sourceVideoLevel = closure_129_0.file.videoMetadata.sourceLevel;
                    }
                    if (undefined !== closure_129_0.file.encodingConfig) {
                      closure_130_0.uploadAnalytics.targetVideoWidth = closure_129_0.file.encodingConfig.targetWidth;
                      closure_130_0.uploadAnalytics.targetVideoHeight = closure_129_0.file.encodingConfig.targetHeight;
                      closure_130_0.uploadAnalytics.targetVideoBitrate = closure_129_0.file.encodingConfig.targetBitrate;
                      closure_130_0.uploadAnalytics.targetVideoCodec = "avc1";
                      closure_130_0.uploadAnalytics.targetVideoFramerate = closure_129_0.file.encodingConfig.frameRate;
                      closure_130_0.uploadAnalytics.targetVideoIsHdr = closure_129_0.file.encodingConfig.createHDR;
                      closure_130_0.uploadAnalytics.progressUpdateGranularity = closure_129_0.file.encodingConfig.progressUpdateGranularity;
                    }
                    closure_130_0.uploadAnalytics.psnr = closure_129_0.file.psnr;
                    closure_130_0.uploadAnalytics.ssim = closure_129_0.file.ssim;
                    closure_130_0.uploadAnalytics.origin = closure_129_0.file.origin;
                    closure_130_0.uploadAnalytics.psnrMeasurementLatencyMs = closure_129_0.file.psnrMeasurementLatencyMs;
                    closure_130_0.uploadAnalytics.ssimMeasurementLatencyMs = closure_129_0.file.ssimMeasurementLatencyMs;
                  }
                  closure_130_0.filename = name;
                  if (null != name) {
                    if (null != uri) {
                      if (null != closure_129_0.file.type) {
                        const parts = name.split(".");
                        const str17 = parts.pop();
                        let formatted;
                        if (str17 != null) {
                          formatted = str17.toLowerCase();
                        }
                        closure_129_3 = formatted;
                        let str3 = "image/jpeg";
                        if ("jpg" !== closure_129_3) {
                          str3 = "image/jpeg";
                          if ("jpeg" !== closure_129_3) {
                            str3 = closure_129_0.file.type;
                          }
                        }
                        closure_129_4 = str3;
                        closure_130_0.uploadAnalytics.convertedMimeType = closure_129_4;
                        const fileSize = closure_129_0.fileSize;
                        size = fileSize;
                        if (fileSize == null) {
                          c3 = 2;
                          c4 = 1;
                          const obj9 = { value: size(5210).getFileData(uri), done: false };
                          return obj9;
                        }
                      }
                    }
                  }
                  const obj10 = { filename: name, uri, type: closure_129_0.file.type };
                  const _HermesInternal2 = HermesInternal;
                  logger.error("Insufficient file data: " + obj10 + " for " + closure_130_0.id);
                  const _Error2 = Error;
                  const obj11 = { filename: name, uri, type: closure_129_0.file.type };
                  const _HermesInternal3 = HermesInternal;
                  const error = new Error("Insufficient file data: " + obj11);
                  throw error;
                }
              }
              const _HermesInternal4 = HermesInternal;
              logger.error("Failed to get compressed file for " + closure_130_0.id);
              c4 = 3;
              const obj12 = { value: closure_130_0, done: true };
              return obj12;
            }
          } else if (arg0 === 1) {
            c4 = 3;
            throw value;
          } else if (arg0 === 2) {
            c4 = 3;
            const obj = { value, done: true };
            return obj;
          } else {
            size = value.size;
          }
          closure_129_5 = size;
          closure_130_0.postCompressionSize = closure_129_5;
          closure_130_0.currentSize = closure_129_5;
          if (null == closure_129_5) {
            const _HermesInternal = HermesInternal;
            logger.error("Size missing from file data for " + closure_130_0.id);
            const _Error = Error;
            const error1 = new Error("Size missing from file data");
            throw error1;
          } else {
            const _HermesInternal7 = HermesInternal;
            logger.log("Completed compression and conversion. Output size=" + closure_129_5 + " bytes; filename=" + name + "; uri=" + uri + "; originalMimeType=" + closure_130_0.mimeType + "; mimeType=" + closure_129_4 + " for " + closure_130_0.id);
            const obj13 = { uri, filename: name, mimeType: closure_129_4 };
            closure_129_6 = obj13;
            const obj15 = {};
            const merged = Object.assign(closure_130_0.item);
            const merged1 = Object.assign(closure_129_6);
            closure_130_0.item = obj15;
            closure_130_0.reactNativeFilePrepped = true;
            c4 = 3;
            const obj16 = { value: closure_130_0, done: true };
            return obj16;
          }
        }
      } catch (tmp113) {
        c4 = tmp;
        throw tmp113;
      }
    }
  })();
};
CloudUpload["tryConvertToWebP"] = function tryConvertToWebP(file, arg1, id) {
  closure_0 = file;
  closure_1 = arg1;
  closure_2 = id;
  return (async (arg0, value) => {
    if (c9 === 2) {
      c9 = 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) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c9 = 2;
        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_5 = tmp3;
            closure_4 = tmp5;
            closure_132_0 = undefined;
            closure_132_1 = undefined;
            closure_132_2 = undefined;
            closure_132_3 = undefined;
            closure_132_4 = undefined;
            closure_132_5 = undefined;
            closure_132_6 = undefined;
            const imageAttachmentMezzanineV2Config = unknown_error(hashTimeMs[27]).getImageAttachmentMezzanineV2Config({ location: "CloudUpload.maybeConvertToWebP" });
            if (imageAttachmentMezzanineV2Config.enabled) {
              if (null == size) {
                const _HermesInternal6 = HermesInternal;
                logger.warn("webp conversion skipped for " + closure_2 + ": no file");
                c9 = 3;
                return { value: null, done: true };
              } else {
                if (null != imageAttachmentMezzanineV2Config.maxFileSizeBytes) {
                  if (size.size > imageAttachmentMezzanineV2Config.maxFileSizeBytes) {
                    const _HermesInternal5 = HermesInternal;
                    logger.warn("webp conversion skipped for " + closure_2 + ": too big");
                    c9 = 3;
                    return { value: null, done: true };
                  }
                }
                if (compressTimeMs()) {
                  c9 = 3;
                  return { value: null, done: true };
                } else {
                  const _performance2 = performance;
                  closure_132_2 = performance.now();
                  closure_132_3 = { compressTimeMs: 0 };
                  c7 = 1;
                  c8 = 2;
                  c9 = 1;
                  const obj4 = { value: tmp97(tmp98[29])(tmp98[28], tmp98.paths), done: false };
                  return obj4;
                }
              }
            } else {
              const _HermesInternal4 = HermesInternal;
              logger.warn("webp conversion skipped for " + closure_2 + ": not enabled");
              c9 = 3;
              return { value: null, done: true };
            }
            const obj9 = unknown_error(hashTimeMs[27]);
            tmp97 = unknown_error;
          }
        } else {
          if (1 === tmp8) {
            c7 = 0;
            closure_132_7 = closure_6;
            const _HermesInternal3 = HermesInternal;
            logger.warn("webp conversion failed for " + closure_133_2 + ":", closure_132_7);
            let UNKNOWN_ERROR;
            if (closure_132_1 != null) {
              UNKNOWN_ERROR = closure_132_1.UNKNOWN_ERROR;
            }
            unknown_error = UNKNOWN_ERROR;
            if (UNKNOWN_ERROR == null) {
              unknown_error = "unknown_error";
            }
            closure_132_3.conversionFailureReason = unknown_error;
          } else if (2 === tmp8) {
            if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 0;
              c9 = 3;
              const obj5 = { value, done: true };
              return obj5;
            } else {
              closure_132_4 = value;
              closure_132_1 = closure_132_4.ConversionFailureReason;
              c8 = 3;
              c9 = 1;
              const obj6 = { value: closure_132_4.maybeConvertToWebP(closure_133_0), done: false };
              return obj6;
            }
          } else if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 0;
            c9 = 3;
            const obj7 = { value, done: true };
            return obj7;
          } else {
            closure_132_0 = value;
            if (closure_133_1()) {
              c7 = 0;
              c9 = 3;
              return { value: null, done: true };
            } else {
              if (closure_132_0.success) {
                if (null != closure_132_0.convertedBlob) {
                  const compressionRatio = closure_132_0.compressionRatio;
                  ({ sizeBefore, sizeAfter } = closure_132_0);
                  const _HermesInternal2 = HermesInternal;
                  logger.log("webp conversion worked for " + closure_133_2 + ": " + sizeBefore + " -> " + sizeAfter + " bytes (" + compressionRatio.toFixed(2) + "x)");
                  const _File = File;
                  const items = [closure_132_0.convertedBlob];
                  const obj = { type: "image/webp", lastModified: closure_133_0.lastModified };
                  file = new File(items, closure_133_0.name, obj);
                  closure_132_3.convertedFile = file;
                  closure_132_3.convertedMimeType = "image/webp";
                  hashTimeMs = closure_132_0.hashTimeMs;
                  if (hashTimeMs == null) {
                    hashTimeMs = undefined;
                  }
                  closure_132_3.hashTimeMs = hashTimeMs;
                }
                c7 = 0;
              }
              const reason = closure_132_0.reason;
              UNKNOWN_ERROR = reason;
              if (reason == null) {
                UNKNOWN_ERROR = closure_132_1.UNKNOWN_ERROR;
              }
              closure_132_5 = UNKNOWN_ERROR;
              const _HermesInternal = HermesInternal;
              logger.log("webp conversion skipped for " + closure_133_2 + ": " + closure_132_5);
              closure_132_3.conversionFailureReason = closure_132_5;
            }
          }
          const _Math = Math;
          const _performance = performance;
          closure_132_6 = Math.round(performance.now() - closure_132_2);
          compressTimeMs = undefined;
          if (closure_132_0 != null) {
            compressTimeMs = closure_132_0.compressTimeMs;
          }
          if (compressTimeMs == null) {
            compressTimeMs = closure_132_6;
          }
          closure_132_3.compressTimeMs = compressTimeMs;
          c9 = 3;
          const obj8 = { value: closure_132_3, done: true };
          return obj8;
        }
      } catch (tmp85) {
        closure_6 = tmp85;
        if (tmp4 === c7) {
          c9 = tmp2;
          throw tmp85;
        } else {
          c8 = tmp;
        }
      }
    }
  })();
};
CloudUpload["tryConvertHeicToJpeg"] = function tryConvertHeicToJpeg(file, arg1, id, quality, maxFileSizeBytes) {
  closure_0 = file;
  closure_1 = arg1;
  closure_2 = id;
  closure_3 = quality;
  closure_4 = maxFileSizeBytes;
  return (async (arg0, value) => {
    if (c5 === 2) {
      c5 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp6 === 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 {
        c5 = 2;
        if (0 === c4) {
          if (arg0 === 1) {
            c5 = 3;
            throw value;
          } else if (arg0 === 2) {
            c5 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_0 = tmp7;
            let convertFileToJpeg;
            closure_128_1 = undefined;
            if (null != closure_0) {
              if (!tmp3()) {
                c3 = 1;
                c4 = 2;
                c5 = 1;
                const obj4 = { value: closure_0(tmp30[29])(tmp30[30], tmp30.paths), done: false };
                return obj4;
              }
            }
            c5 = 3;
            return { value: null, done: true };
          }
        } else if (1 === tmp7) {
          c3 = 0;
          closure_128_2 = tmp30;
          const _HermesInternal = HermesInternal;
          logger.warn("heic conversion threw for " + closure_129_2 + ":", closure_128_2);
          const obj5 = { convertedFile: null, analytics: { convertedMimeType: null, conversionFailureReason: "unknown_error", compressTimeMs: 0 } };
          c5 = 3;
          const obj6 = { value: obj5, done: true };
          return obj6;
        } else if (2 === tmp7) {
          if (arg0 === 1) {
            c5 = 3;
            throw value;
          } else if (arg0 === 2) {
            c3 = 0;
            c5 = 3;
            const obj7 = { value, done: true };
            return obj7;
          } else {
            convertFileToJpeg = value.convertFileToJpeg;
            c4 = 3;
            c5 = 1;
            const obj8 = { value: convertFileToJpeg(closure_129_0, "heic", closure_129_3, closure_129_4), done: false };
            return obj8;
          }
        } else if (arg0 === 1) {
          c5 = 3;
          throw value;
        } else if (arg0 === 2) {
          c3 = 0;
          c5 = 3;
          const obj9 = { value, done: true };
          return obj9;
        } else {
          closure_128_1 = value;
          let tmp11 = null;
          if (!closure_129_1()) {
            tmp11 = closure_128_1;
          }
          c3 = 0;
          c5 = 3;
          const obj = { value: tmp11, done: true };
          return obj;
        }
      } catch (tmp30) {
        if (tmp4 === c3) {
          c5 = tmp2;
          throw tmp30;
        } else {
          c4 = tmp;
        }
      }
    }
  })();
};
prototype["handleError"] = function handleError(error) {
  const self = this;
  this.setStatus(obj.ERROR);
  this.error = error;
  this.trackUploadFinished(obj.ERROR);
  try {
    self.emit("error", error);
    self.removeAllListeners();
  } catch (err) {
  }
};
prototype["handleComplete"] = function handleComplete(arg0) {
  this.setStatus(obj.COMPLETED);
  logger.log("Upload complete for " + this.id);
  this.emit("complete", arg0);
  this.removeAllListeners();
};
prototype["_cancel"] = function _cancel(COMPLETED, arg1) {
  const self = this;
  logger.log(arg1);
  this._aborted = true;
  const _abortController = this._abortController;
  _abortController.abort();
  this.trackUploadFinished(COMPLETED);
  if (this.status === obj.COMPLETED) {
    self.delete();
  }
  self.setStatus(COMPLETED);
  self.emit("complete");
  self.removeAllListeners();
};
prototype["cancel"] = function cancel() {
  this._cancel(obj.CANCELED, "Cancelled called for " + this.id);
};
prototype["removeFromMsgDraft"] = function removeFromMsgDraft() {
  this._cancel(obj.REMOVED_FROM_MSG_DRAFT, "Removed from draft for " + this.id);
};
prototype["isCancelled"] = function isCancelled() {
  return this.status === obj.CANCELED || this.status === tmp.REMOVED_FROM_MSG_DRAFT;
};
prototype["applyConversionAnalytics"] = function applyConversionAnalytics(analytics) {
  const self = this;
  ({ convertedMimeType, conversionFailureReason, imageCompressionQuality, imageEncoderType } = analytics);
  if (null != convertedMimeType) {
    self.uploadAnalytics.convertedMimeType = convertedMimeType;
  }
  if (null != conversionFailureReason) {
    self.uploadAnalytics.conversionFailureReason = conversionFailureReason;
  }
  self.uploadAnalytics.timing.compressTimeMs = analytics.compressTimeMs;
  if (null != imageCompressionQuality) {
    self.uploadAnalytics.imageCompressionQuality = imageCompressionQuality;
  }
  if (null != imageEncoderType) {
    self.uploadAnalytics.imageEncoderType = imageEncoderType;
  }
};
prototype["applyItemConversionAnalytics"] = function applyItemConversionAnalytics() {
  const self = this;
  const item = this.item;
  let tmp = item.platform === Upload2.UploadPlatform.WEB;
  if (tmp) {
    tmp = null != item.imageConversionAnalytics;
  }
  if (tmp) {
    const result = self.applyConversionAnalytics(item.imageConversionAnalytics);
  }
};
prototype["delete"] = function delete() {
  const self = this;
  return (async (arg0, value) => {
    if (v3 === 2) {
      v3 = 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 obj3 = { value, done: true };
        return obj3;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        v3 = 2;
        if (0 === c1) {
          if (arg0 === 1) {
            v3 = 3;
            throw value;
          } else if (arg0 === 2) {
            v3 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else if (null != self.uploadedFilename) {
            const uploadTarget = v3(5255).getUploadTarget(tmp17.item.target);
            dependencyMap = 1;
            const deleteUploadURL = uploadTarget.getDeleteUploadURL(tmp17.uploadedFilename);
            const HTTP = v3(1270).HTTP;
            c1 = 2;
            v3 = 1;
            const obj5 = { value: HTTP.del(deleteUploadURL), done: false };
            return obj5;
          }
        } else {
          if (1 === tmp6) {
            dependencyMap = 0;
          } else if (arg0 === 1) {
            v3 = 3;
            throw value;
          } else if (arg0 !== 2) {
            dependencyMap = 0;
          }
          dependencyMap = 0;
          v3 = 3;
          const obj = { value, done: true };
          return obj;
        }
        v3 = 3;
      } catch (tmp10) {
        if (tmp3 === dependencyMap) {
          v3 = tmp2;
          throw tmp10;
        } else {
          c1 = tmp;
        }
      }
    }
  })();
};
prototype["setResponseUrl"] = function setResponseUrl(upload_url) {
  this.responseUrl = upload_url;
  this.responseUrlSetAt = Date.now();
};
CloudUpload["isResponseUrlStale"] = function isResponseUrlStale(responseUrlSetAt) {
  if (null == responseUrlSetAt) {
    return true;
  } else {
    const _Date = Date;
    const result = 12 * DurationsDefault.Millis.HOUR;
    return Date.now() - responseUrlSetAt > result;
  }
};
prototype["ensureFreshResponseUrl"] = function ensureFreshResponseUrl() {
  const self = this;
  return (async (arg0, value) => {
    if (c5 === 2) {
      c5 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp6 === 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 {
        c5 = 2;
        if (0 === c4) {
          if (arg0 === 1) {
            c5 = 3;
            throw value;
          } else if (arg0 === 2) {
            c5 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_1 = tmp3;
            _self = tmp7;
            closure_128_0 = undefined;
            closure_128_1 = undefined;
            let createAttachmentURL;
            if (responseUrlStale.isResponseUrlStale(self.responseUrlSetAt)) {
              c4 = 1;
              c5 = 1;
              const obj4 = { value: _self(tmp40[20]).default.getUploadPayload(self), done: false };
              return obj4;
            } else {
              c5 = 3;
            }
          }
        } else if (1 === tmp7) {
          if (arg0 === 1) {
            c5 = 3;
            throw value;
          } else if (arg0 === 2) {
            c5 = 3;
            const obj5 = { value, done: true };
            return obj5;
          } else {
            closure_128_1 = value;
            const uploadTarget = _self(tmp40[21]).getUploadTarget(closure_129_0.item.target);
            createAttachmentURL = uploadTarget.getCreateAttachmentURL(closure_129_0.channelId);
            c3 = 1;
            const HTTP = _self(tmp40[8]).HTTP;
            const request = { url: createAttachmentURL, body: null, headers: null };
            const obj6 = { files: null };
            const items = [closure_128_1];
            obj6.files = items;
            request.body = obj6;
            request.headers = closure_129_0.buildOriginalMd5Headers();
            const merged = Object.assign(closure_129_0.createAttachmentUrlRetryOpts());
            request.rejectWithError = true;
            c4 = 3;
            c5 = 1;
            const obj7 = { value: HTTP.post(request), done: false };
            return obj7;
          }
        } else if (2 === tmp7) {
          c3 = 0;
          closure_128_3 = tmp40;
          if (closure_128_3 instanceof _self(tmp40[8]).HTTPResponseError) {
            const obj8 = { response: closure_128_3 };
            throw new ResumableUploadError("upload", obj8);
          } else {
            throw closure_128_3;
          }
        } else if (arg0 === 1) {
          c5 = 3;
          throw value;
        } else if (arg0 === 2) {
          c3 = 0;
          c5 = 3;
          const obj10 = { value, done: true };
          return obj10;
        } else {
          closure_128_0 = value;
          c3 = 0;
          const body = closure_128_0.body;
          let first;
          if (body != null) {
            const attachments = body.attachments;
            if (attachments != null) {
              first = attachments[0];
            }
          }
          if (null != first) {
            closure_129_0.setResponseUrl(closure_128_0.body.attachments[0].upload_url);
            closure_129_0.setUploadedFilename(closure_128_0.body.attachments[0].upload_filename);
          }
        }
        const obj = { response: closure_128_0 };
        throw new ResumableUploadError("upload", obj);
      } catch (tmp40) {
        if (tmp4 === c3) {
          c5 = tmp2;
          throw tmp40;
        } else {
          c4 = tmp;
        }
      }
    }
  })();
};
prototype["setStatus"] = function setStatus(status) {
  this.status = status;
};
prototype["setFilename"] = function setFilename(name) {
  this.filename = name;
};
prototype["setUploadedFilename"] = function setUploadedFilename(upload_filename) {
  this.uploadedFilename = upload_filename;
};
prototype["trackUploadStart"] = function trackUploadStart() {
  const obj3 = { file_size: this.currentSize, mime_type: null, video_upload_quality: null, data_saving_mode: null, low_quality_image_mode: null, channel_id: null, connection_type: null, effective_connection_speed: null, service_provider: null };
  let str = this.mimeType;
  if (str == null) {
    str = "unknown";
  }
  obj3.mime_type = str;
  ({ videoUploadQuality: obj2.video_upload_quality, dataSavingMode: obj2.data_saving_mode, dataSavingMode: obj2.low_quality_image_mode } = UnsyncedUserSettingsStore);
  obj3.channel_id = this.channelId;
  obj3.connection_type = NetworkStore.getType();
  obj3.effective_connection_speed = NetworkStore.getEffectiveConnectionSpeed();
  obj3.service_provider = NetworkStore.getServiceProvider();
  AnalyticsUtilsDefault.track(constants.ATTACHMENT_UPLOAD_STARTED, obj3);
};
prototype["trackUploadFinished"] = function trackUploadFinished(COMPLETED) {
  const self = this;
  let num = -1;
  if (null != this.startTime) {
    const _performance = performance;
    num = performance.now() - self.startTime;
  }
  const obj3 = { duration_ms: num, file_size: self.currentSize, pre_compression_file_size: self.preCompressionSize, final_state: COMPLETED, mime_type: null, num_upload_attempts: null, error_code: null, video_upload_quality: null, data_saving_mode: null, low_quality_image_mode: null, compress_time_ms: null, get_upload_url_time_ms: null, upload_time_ms: null, converted_mime_type: null, image_compression_quality: null, video_compression_quality: null, image_encoder_type: null, was_converted: null, was_compressed: null, source_media_width: null, source_media_height: null, source_media_format: null, uploaded_image_width: null, uploaded_image_height: null, source_video_bitrate: null, video_duration_ms: null, source_video_profile_name: null, source_video_profile_level: null, target_video_width: null, target_video_height: null, target_video_bitrate: null, target_video_codec: null, target_video_framerate: null, target_video_is_hdr: null, hevc_is_supported: null, progress_update_granularity: null, source_video_framerate: null, channel_id: null, hash_time_ms: null, psnr: null, ssim: null, origin: null, psnr_measurement_latency_ms: null, ssim_measurement_latency_ms: null, upload_resumption_count: null, upload_resumption_reason: null, upload_resumption_position: null, upload_resumption_check_time_ms: null, conversion_failure_reason: null, upload_http_client: null, connection_type: null, effective_connection_speed: null, service_provider: null };
  let str = self.mimeType;
  if (str == null) {
    str = "unknown";
  }
  obj3.mime_type = str;
  let num2 = self.uploadAnalytics.numUploadAttempts;
  if (num2 == null) {
    num2 = 1;
  }
  obj3.num_upload_attempts = num2;
  obj3.error_code = self.error;
  ({ videoUploadQuality: obj2.video_upload_quality, dataSavingMode: obj2.data_saving_mode, dataSavingMode: obj2.low_quality_image_mode } = UnsyncedUserSettingsStore);
  obj3.compress_time_ms = self.uploadAnalytics.timing.compressTimeMs;
  obj3.get_upload_url_time_ms = self.uploadAnalytics.timing.getUploadUrlTimeMs;
  obj3.upload_time_ms = self.uploadAnalytics.timing.uploadTimeMs;
  let str2 = self.uploadAnalytics.convertedMimeType;
  if (str2 == null) {
    str2 = "unknown";
  }
  obj3.converted_mime_type = str2;
  let num3 = self.uploadAnalytics.imageCompressionQuality;
  if (num3 == null) {
    num3 = 0;
  }
  obj3.image_compression_quality = num3;
  let str3 = self.uploadAnalytics.videoCompressionQuality;
  if (str3 == null) {
    str3 = "unknown";
  }
  obj3.video_compression_quality = str3;
  let str4 = self.uploadAnalytics.imageEncoderType;
  if (str4 == null) {
    str4 = "unknown";
  }
  obj3.image_encoder_type = str4;
  obj3.was_converted = null != self.uploadAnalytics.convertedMimeType && self.mimeType !== self.uploadAnalytics.convertedMimeType;
  obj3.was_compressed = self.currentSize < self.preCompressionSize;
  obj3.source_media_width = self.uploadAnalytics.sourceMediaWidth;
  obj3.source_media_height = self.uploadAnalytics.sourceMediaHeight;
  obj3.source_media_format = self.uploadAnalytics.sourceMediaFormat;
  obj3.uploaded_image_width = self.uploadAnalytics.uploadedImageWidth;
  obj3.uploaded_image_height = self.uploadAnalytics.uploadedImageHeight;
  obj3.source_video_bitrate = self.uploadAnalytics.sourceVideoBitrate;
  obj3.video_duration_ms = self.uploadAnalytics.videoDurationMs;
  obj3.source_video_profile_name = self.uploadAnalytics.sourceVideoProfile;
  obj3.source_video_profile_level = self.uploadAnalytics.sourceVideoLevel;
  obj3.target_video_width = self.uploadAnalytics.targetVideoWidth;
  obj3.target_video_height = self.uploadAnalytics.targetVideoHeight;
  obj3.target_video_bitrate = self.uploadAnalytics.targetVideoBitrate;
  obj3.target_video_codec = self.uploadAnalytics.targetVideoCodec;
  obj3.target_video_framerate = self.uploadAnalytics.targetVideoFramerate;
  obj3.target_video_is_hdr = self.uploadAnalytics.targetVideoIsHdr;
  obj3.hevc_is_supported = self.uploadAnalytics.hevcIsSupported;
  obj3.progress_update_granularity = self.uploadAnalytics.progressUpdateGranularity;
  obj3.source_video_framerate = self.uploadAnalytics.sourceVideoFramerate;
  obj3.channel_id = self.channelId;
  obj3.hash_time_ms = self.uploadAnalytics.timing.hashTimeMs;
  obj3.psnr = self.uploadAnalytics.psnr;
  obj3.ssim = self.uploadAnalytics.ssim;
  obj3.origin = self.uploadAnalytics.origin;
  obj3.psnr_measurement_latency_ms = self.uploadAnalytics.psnrMeasurementLatencyMs;
  obj3.ssim_measurement_latency_ms = self.uploadAnalytics.ssimMeasurementLatencyMs;
  obj3.upload_resumption_count = self.uploadAnalytics.uploadResumptionCount;
  obj3.upload_resumption_reason = self.uploadAnalytics.uploadResumptionReason;
  obj3.upload_resumption_position = self.uploadAnalytics.uploadResumptionPosition;
  obj3.upload_resumption_check_time_ms = self.uploadAnalytics.timing.resumptionCheckTimeMs;
  obj3.conversion_failure_reason = self.uploadAnalytics.conversionFailureReason;
  let str5 = "httputils";
  if (self._libdiscoreEnabled) {
    str5 = "libdiscore";
  }
  obj3.upload_http_client = str5;
  obj3.connection_type = NetworkStore.getType();
  obj3.effective_connection_speed = NetworkStore.getEffectiveConnectionSpeed();
  obj3.service_provider = NetworkStore.getServiceProvider();
  AnalyticsUtilsDefault.track(constants.ATTACHMENT_UPLOAD_FINISHED, obj3);
};
let size = fn(2);
let result = size.fileFinishedImporting("lib/uploader/CloudUpload.tsx");

export { ResumableUploadError };
export { CloudUploadStatus };
export { CloudUpload };